id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
150,600 | ceph/go-ceph | rados/ioctx.go | ListLockers | func (ioctx *IOContext) ListLockers(oid, name string) (*LockInfo, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_tag := (*C.char)(C.malloc(C.size_t(1024)))
c_clients := (*C.char)(C.malloc(C.size_t(1024)))
c_cookies := (*C.char)(C.malloc(C.size_t(1024)))
c_addrs := (*C.char)(C.malloc(C.size_t(1024)))
var c_exclusive C.int
c_tag_len := C.size_t(1024)
c_clients_len := C.size_t(1024)
c_cookies_len := C.size_t(1024)
c_addrs_len := C.size_t(1024)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_tag))
defer C.free(unsafe.Pointer(c_clients))
defer C.free(unsafe.Pointer(c_cookies))
defer C.free(unsafe.Pointer(c_addrs))
ret := C.rados_list_lockers(
ioctx.ioctx,
c_oid,
c_name,
&c_exclusive,
c_tag,
&c_tag_len,
c_clients,
&c_clients_len,
c_cookies,
&c_cookies_len,
c_addrs,
&c_addrs_len)
splitCString := func(items *C.char, itemsLen C.size_t) []string {
currLen := 0
clients := []string{}
for currLen < int(itemsLen) {
client := C.GoString(C.nextChunk(&items))
clients = append(clients, client)
currLen += len(client) + 1
}
return clients
}
if ret < 0 {
return nil, RadosError(int(ret))
} else {
return &LockInfo{int(ret), c_exclusive == 1, C.GoString(c_tag), splitCString(c_clients, c_clients_len), splitCString(c_cookies, c_cookies_len), splitCString(c_addrs, c_addrs_len)}, nil
}
} | go | func (ioctx *IOContext) ListLockers(oid, name string) (*LockInfo, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_tag := (*C.char)(C.malloc(C.size_t(1024)))
c_clients := (*C.char)(C.malloc(C.size_t(1024)))
c_cookies := (*C.char)(C.malloc(C.size_t(1024)))
c_addrs := (*C.char)(C.malloc(C.size_t(1024)))
var c_exclusive C.int
c_tag_len := C.size_t(1024)
c_clients_len := C.size_t(1024)
c_cookies_len := C.size_t(1024)
c_addrs_len := C.size_t(1024)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_tag))
defer C.free(unsafe.Pointer(c_clients))
defer C.free(unsafe.Pointer(c_cookies))
defer C.free(unsafe.Pointer(c_addrs))
ret := C.rados_list_lockers(
ioctx.ioctx,
c_oid,
c_name,
&c_exclusive,
c_tag,
&c_tag_len,
c_clients,
&c_clients_len,
c_cookies,
&c_cookies_len,
c_addrs,
&c_addrs_len)
splitCString := func(items *C.char, itemsLen C.size_t) []string {
currLen := 0
clients := []string{}
for currLen < int(itemsLen) {
client := C.GoString(C.nextChunk(&items))
clients = append(clients, client)
currLen += len(client) + 1
}
return clients
}
if ret < 0 {
return nil, RadosError(int(ret))
} else {
return &LockInfo{int(ret), c_exclusive == 1, C.GoString(c_tag), splitCString(c_clients, c_clients_len), splitCString(c_cookies, c_cookies_len), splitCString(c_addrs, c_addrs_len)}, nil
}
} | [
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"ListLockers",
"(",
"oid",
",",
"name",
"string",
")",
"(",
"*",
"LockInfo",
",",
"error",
")",
"{",
"c_oid",
":=",
"C",
".",
"CString",
"(",
"oid",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n\n",
"c_tag",
":=",
"(",
"*",
"C",
".",
"char",
")",
"(",
"C",
".",
"malloc",
"(",
"C",
".",
"size_t",
"(",
"1024",
")",
")",
")",
"\n",
"c_clients",
":=",
"(",
"*",
"C",
".",
"char",
")",
"(",
"C",
".",
"malloc",
"(",
"C",
".",
"size_t",
"(",
"1024",
")",
")",
")",
"\n",
"c_cookies",
":=",
"(",
"*",
"C",
".",
"char",
")",
"(",
"C",
".",
"malloc",
"(",
"C",
".",
"size_t",
"(",
"1024",
")",
")",
")",
"\n",
"c_addrs",
":=",
"(",
"*",
"C",
".",
"char",
")",
"(",
"C",
".",
"malloc",
"(",
"C",
".",
"size_t",
"(",
"1024",
")",
")",
")",
"\n\n",
"var",
"c_exclusive",
"C",
".",
"int",
"\n",
"c_tag_len",
":=",
"C",
".",
"size_t",
"(",
"1024",
")",
"\n",
"c_clients_len",
":=",
"C",
".",
"size_t",
"(",
"1024",
")",
"\n",
"c_cookies_len",
":=",
"C",
".",
"size_t",
"(",
"1024",
")",
"\n",
"c_addrs_len",
":=",
"C",
".",
"size_t",
"(",
"1024",
")",
"\n\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_oid",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_tag",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_clients",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_cookies",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_addrs",
")",
")",
"\n\n",
"ret",
":=",
"C",
".",
"rados_list_lockers",
"(",
"ioctx",
".",
"ioctx",
",",
"c_oid",
",",
"c_name",
",",
"&",
"c_exclusive",
",",
"c_tag",
",",
"&",
"c_tag_len",
",",
"c_clients",
",",
"&",
"c_clients_len",
",",
"c_cookies",
",",
"&",
"c_cookies_len",
",",
"c_addrs",
",",
"&",
"c_addrs_len",
")",
"\n\n",
"splitCString",
":=",
"func",
"(",
"items",
"*",
"C",
".",
"char",
",",
"itemsLen",
"C",
".",
"size_t",
")",
"[",
"]",
"string",
"{",
"currLen",
":=",
"0",
"\n",
"clients",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"currLen",
"<",
"int",
"(",
"itemsLen",
")",
"{",
"client",
":=",
"C",
".",
"GoString",
"(",
"C",
".",
"nextChunk",
"(",
"&",
"items",
")",
")",
"\n",
"clients",
"=",
"append",
"(",
"clients",
",",
"client",
")",
"\n",
"currLen",
"+=",
"len",
"(",
"client",
")",
"+",
"1",
"\n",
"}",
"\n",
"return",
"clients",
"\n",
"}",
"\n\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"else",
"{",
"return",
"&",
"LockInfo",
"{",
"int",
"(",
"ret",
")",
",",
"c_exclusive",
"==",
"1",
",",
"C",
".",
"GoString",
"(",
"c_tag",
")",
",",
"splitCString",
"(",
"c_clients",
",",
"c_clients_len",
")",
",",
"splitCString",
"(",
"c_cookies",
",",
"c_cookies_len",
")",
",",
"splitCString",
"(",
"c_addrs",
",",
"c_addrs_len",
")",
"}",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // List clients that have locked the named object lock and information about the lock.
// The number of bytes required in each buffer is put in the corresponding size out parameter.
// If any of the provided buffers are too short, -ERANGE is returned after these sizes are filled in. | [
"List",
"clients",
"that",
"have",
"locked",
"the",
"named",
"object",
"lock",
"and",
"information",
"about",
"the",
"lock",
".",
"The",
"number",
"of",
"bytes",
"required",
"in",
"each",
"buffer",
"is",
"put",
"in",
"the",
"corresponding",
"size",
"out",
"parameter",
".",
"If",
"any",
"of",
"the",
"provided",
"buffers",
"are",
"too",
"short",
"-",
"ERANGE",
"is",
"returned",
"after",
"these",
"sizes",
"are",
"filled",
"in",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L803-L855 |
150,601 | ceph/go-ceph | rados/ioctx.go | BreakLock | func (ioctx *IOContext) BreakLock(oid, name, client, cookie string) (int, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_client := C.CString(client)
c_cookie := C.CString(cookie)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_client))
defer C.free(unsafe.Pointer(c_cookie))
// 0 on success, negative error code on failure
// -ENOENT if the lock is not held by the specified (client, cookie) pair
// -EINVAL if the client cannot be parsed
ret := C.rados_break_lock(
ioctx.ioctx,
c_oid,
c_name,
c_client,
c_cookie)
switch ret {
case 0:
return int(ret), nil
case -C.ENOENT:
return int(ret), nil
case -C.EINVAL: // -EINVAL
return int(ret), nil
default:
return int(ret), RadosError(int(ret))
}
} | go | func (ioctx *IOContext) BreakLock(oid, name, client, cookie string) (int, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_client := C.CString(client)
c_cookie := C.CString(cookie)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_client))
defer C.free(unsafe.Pointer(c_cookie))
// 0 on success, negative error code on failure
// -ENOENT if the lock is not held by the specified (client, cookie) pair
// -EINVAL if the client cannot be parsed
ret := C.rados_break_lock(
ioctx.ioctx,
c_oid,
c_name,
c_client,
c_cookie)
switch ret {
case 0:
return int(ret), nil
case -C.ENOENT:
return int(ret), nil
case -C.EINVAL: // -EINVAL
return int(ret), nil
default:
return int(ret), RadosError(int(ret))
}
} | [
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"BreakLock",
"(",
"oid",
",",
"name",
",",
"client",
",",
"cookie",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"c_oid",
":=",
"C",
".",
"CString",
"(",
"oid",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"c_client",
":=",
"C",
".",
"CString",
"(",
"client",
")",
"\n",
"c_cookie",
":=",
"C",
".",
"CString",
"(",
"cookie",
")",
"\n\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_oid",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_client",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_cookie",
")",
")",
"\n\n",
"// 0 on success, negative error code on failure",
"// -ENOENT if the lock is not held by the specified (client, cookie) pair",
"// -EINVAL if the client cannot be parsed",
"ret",
":=",
"C",
".",
"rados_break_lock",
"(",
"ioctx",
".",
"ioctx",
",",
"c_oid",
",",
"c_name",
",",
"c_client",
",",
"c_cookie",
")",
"\n\n",
"switch",
"ret",
"{",
"case",
"0",
":",
"return",
"int",
"(",
"ret",
")",
",",
"nil",
"\n",
"case",
"-",
"C",
".",
"ENOENT",
":",
"return",
"int",
"(",
"ret",
")",
",",
"nil",
"\n",
"case",
"-",
"C",
".",
"EINVAL",
":",
"// -EINVAL",
"return",
"int",
"(",
"ret",
")",
",",
"nil",
"\n",
"default",
":",
"return",
"int",
"(",
"ret",
")",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Releases a shared or exclusive lock on an object, which was taken by the specified client. | [
"Releases",
"a",
"shared",
"or",
"exclusive",
"lock",
"on",
"an",
"object",
"which",
"was",
"taken",
"by",
"the",
"specified",
"client",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L858-L890 |
150,602 | ceph/go-ceph | rbd/rbd.go | GetTrashList | func GetTrashList(ioctx *rados.IOContext) ([]TrashInfo, error) {
var num_entries C.size_t
// Call rbd_trash_list with nil pointer to get number of trash entries.
if C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), nil, &num_entries); num_entries == 0 {
return nil, nil
}
c_entries := make([]C.rbd_trash_image_info_t, num_entries)
trashList := make([]TrashInfo, num_entries)
if ret := C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), &c_entries[0], &num_entries); ret < 0 {
return nil, RBDError(ret)
}
for i, ti := range c_entries {
trashList[i] = TrashInfo{
Id: C.GoString(ti.id),
Name: C.GoString(ti.name),
DeletionTime: time.Unix(int64(ti.deletion_time), 0),
DefermentEndTime: time.Unix(int64(ti.deferment_end_time), 0),
}
}
// Free rbd_trash_image_info_t pointers
C.rbd_trash_list_cleanup(&c_entries[0], num_entries)
return trashList, nil
} | go | func GetTrashList(ioctx *rados.IOContext) ([]TrashInfo, error) {
var num_entries C.size_t
// Call rbd_trash_list with nil pointer to get number of trash entries.
if C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), nil, &num_entries); num_entries == 0 {
return nil, nil
}
c_entries := make([]C.rbd_trash_image_info_t, num_entries)
trashList := make([]TrashInfo, num_entries)
if ret := C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), &c_entries[0], &num_entries); ret < 0 {
return nil, RBDError(ret)
}
for i, ti := range c_entries {
trashList[i] = TrashInfo{
Id: C.GoString(ti.id),
Name: C.GoString(ti.name),
DeletionTime: time.Unix(int64(ti.deletion_time), 0),
DefermentEndTime: time.Unix(int64(ti.deferment_end_time), 0),
}
}
// Free rbd_trash_image_info_t pointers
C.rbd_trash_list_cleanup(&c_entries[0], num_entries)
return trashList, nil
} | [
"func",
"GetTrashList",
"(",
"ioctx",
"*",
"rados",
".",
"IOContext",
")",
"(",
"[",
"]",
"TrashInfo",
",",
"error",
")",
"{",
"var",
"num_entries",
"C",
".",
"size_t",
"\n\n",
"// Call rbd_trash_list with nil pointer to get number of trash entries.",
"if",
"C",
".",
"rbd_trash_list",
"(",
"C",
".",
"rados_ioctx_t",
"(",
"ioctx",
".",
"Pointer",
"(",
")",
")",
",",
"nil",
",",
"&",
"num_entries",
")",
";",
"num_entries",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"c_entries",
":=",
"make",
"(",
"[",
"]",
"C",
".",
"rbd_trash_image_info_t",
",",
"num_entries",
")",
"\n",
"trashList",
":=",
"make",
"(",
"[",
"]",
"TrashInfo",
",",
"num_entries",
")",
"\n\n",
"if",
"ret",
":=",
"C",
".",
"rbd_trash_list",
"(",
"C",
".",
"rados_ioctx_t",
"(",
"ioctx",
".",
"Pointer",
"(",
")",
")",
",",
"&",
"c_entries",
"[",
"0",
"]",
",",
"&",
"num_entries",
")",
";",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"RBDError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"ti",
":=",
"range",
"c_entries",
"{",
"trashList",
"[",
"i",
"]",
"=",
"TrashInfo",
"{",
"Id",
":",
"C",
".",
"GoString",
"(",
"ti",
".",
"id",
")",
",",
"Name",
":",
"C",
".",
"GoString",
"(",
"ti",
".",
"name",
")",
",",
"DeletionTime",
":",
"time",
".",
"Unix",
"(",
"int64",
"(",
"ti",
".",
"deletion_time",
")",
",",
"0",
")",
",",
"DefermentEndTime",
":",
"time",
".",
"Unix",
"(",
"int64",
"(",
"ti",
".",
"deferment_end_time",
")",
",",
"0",
")",
",",
"}",
"\n",
"}",
"\n\n",
"// Free rbd_trash_image_info_t pointers",
"C",
".",
"rbd_trash_list_cleanup",
"(",
"&",
"c_entries",
"[",
"0",
"]",
",",
"num_entries",
")",
"\n\n",
"return",
"trashList",
",",
"nil",
"\n",
"}"
] | // GetTrashList returns a slice of TrashInfo structs, containing information about all RBD images
// currently residing in the trash. | [
"GetTrashList",
"returns",
"a",
"slice",
"of",
"TrashInfo",
"structs",
"containing",
"information",
"about",
"all",
"RBD",
"images",
"currently",
"residing",
"in",
"the",
"trash",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rbd/rbd.go#L944-L972 |
150,603 | ceph/go-ceph | rbd/rbd.go | TrashRemove | func TrashRemove(ioctx *rados.IOContext, id string, force bool) error {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
return GetError(C.rbd_trash_remove(C.rados_ioctx_t(ioctx.Pointer()), c_id, C.bool(force)))
} | go | func TrashRemove(ioctx *rados.IOContext, id string, force bool) error {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
return GetError(C.rbd_trash_remove(C.rados_ioctx_t(ioctx.Pointer()), c_id, C.bool(force)))
} | [
"func",
"TrashRemove",
"(",
"ioctx",
"*",
"rados",
".",
"IOContext",
",",
"id",
"string",
",",
"force",
"bool",
")",
"error",
"{",
"c_id",
":=",
"C",
".",
"CString",
"(",
"id",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_id",
")",
")",
"\n\n",
"return",
"GetError",
"(",
"C",
".",
"rbd_trash_remove",
"(",
"C",
".",
"rados_ioctx_t",
"(",
"ioctx",
".",
"Pointer",
"(",
")",
")",
",",
"c_id",
",",
"C",
".",
"bool",
"(",
"force",
")",
")",
")",
"\n",
"}"
] | // TrashRemove permanently deletes the trashed RBD with the specified id. | [
"TrashRemove",
"permanently",
"deletes",
"the",
"trashed",
"RBD",
"with",
"the",
"specified",
"id",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rbd/rbd.go#L975-L980 |
150,604 | ceph/go-ceph | rbd/rbd.go | TrashRestore | func TrashRestore(ioctx *rados.IOContext, id, name string) error {
c_id := C.CString(id)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_id))
defer C.free(unsafe.Pointer(c_name))
return GetError(C.rbd_trash_restore(C.rados_ioctx_t(ioctx.Pointer()), c_id, c_name))
} | go | func TrashRestore(ioctx *rados.IOContext, id, name string) error {
c_id := C.CString(id)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_id))
defer C.free(unsafe.Pointer(c_name))
return GetError(C.rbd_trash_restore(C.rados_ioctx_t(ioctx.Pointer()), c_id, c_name))
} | [
"func",
"TrashRestore",
"(",
"ioctx",
"*",
"rados",
".",
"IOContext",
",",
"id",
",",
"name",
"string",
")",
"error",
"{",
"c_id",
":=",
"C",
".",
"CString",
"(",
"id",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_id",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n\n",
"return",
"GetError",
"(",
"C",
".",
"rbd_trash_restore",
"(",
"C",
".",
"rados_ioctx_t",
"(",
"ioctx",
".",
"Pointer",
"(",
")",
")",
",",
"c_id",
",",
"c_name",
")",
")",
"\n",
"}"
] | // TrashRestore restores the trashed RBD with the specified id back to the pool from whence it
// came, with the specified new name. | [
"TrashRestore",
"restores",
"the",
"trashed",
"RBD",
"with",
"the",
"specified",
"id",
"back",
"to",
"the",
"pool",
"from",
"whence",
"it",
"came",
"with",
"the",
"specified",
"new",
"name",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rbd/rbd.go#L984-L991 |
150,605 | ceph/go-ceph | rados/rados.go | Version | func Version() (int, int, int) {
var c_major, c_minor, c_patch C.int
C.rados_version(&c_major, &c_minor, &c_patch)
return int(c_major), int(c_minor), int(c_patch)
} | go | func Version() (int, int, int) {
var c_major, c_minor, c_patch C.int
C.rados_version(&c_major, &c_minor, &c_patch)
return int(c_major), int(c_minor), int(c_patch)
} | [
"func",
"Version",
"(",
")",
"(",
"int",
",",
"int",
",",
"int",
")",
"{",
"var",
"c_major",
",",
"c_minor",
",",
"c_patch",
"C",
".",
"int",
"\n",
"C",
".",
"rados_version",
"(",
"&",
"c_major",
",",
"&",
"c_minor",
",",
"&",
"c_patch",
")",
"\n",
"return",
"int",
"(",
"c_major",
")",
",",
"int",
"(",
"c_minor",
")",
",",
"int",
"(",
"c_patch",
")",
"\n",
"}"
] | // Version returns the major, minor, and patch components of the version of
// the RADOS library linked against. | [
"Version",
"returns",
"the",
"major",
"minor",
"and",
"patch",
"components",
"of",
"the",
"version",
"of",
"the",
"RADOS",
"library",
"linked",
"against",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/rados.go#L34-L38 |
150,606 | ceph/go-ceph | rados/rados.go | NewConnWithClusterAndUser | func NewConnWithClusterAndUser(clusterName string, userName string) (*Conn, error) {
c_cluster_name := C.CString(clusterName)
defer C.free(unsafe.Pointer(c_cluster_name))
c_name := C.CString(userName)
defer C.free(unsafe.Pointer(c_name))
conn := makeConn()
ret := C.rados_create2(&conn.cluster, c_cluster_name, c_name, 0)
if ret == 0 {
return conn, nil
} else {
return nil, RadosError(int(ret))
}
} | go | func NewConnWithClusterAndUser(clusterName string, userName string) (*Conn, error) {
c_cluster_name := C.CString(clusterName)
defer C.free(unsafe.Pointer(c_cluster_name))
c_name := C.CString(userName)
defer C.free(unsafe.Pointer(c_name))
conn := makeConn()
ret := C.rados_create2(&conn.cluster, c_cluster_name, c_name, 0)
if ret == 0 {
return conn, nil
} else {
return nil, RadosError(int(ret))
}
} | [
"func",
"NewConnWithClusterAndUser",
"(",
"clusterName",
"string",
",",
"userName",
"string",
")",
"(",
"*",
"Conn",
",",
"error",
")",
"{",
"c_cluster_name",
":=",
"C",
".",
"CString",
"(",
"clusterName",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_cluster_name",
")",
")",
"\n\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"userName",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n\n",
"conn",
":=",
"makeConn",
"(",
")",
"\n",
"ret",
":=",
"C",
".",
"rados_create2",
"(",
"&",
"conn",
".",
"cluster",
",",
"c_cluster_name",
",",
"c_name",
",",
"0",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"conn",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] | // NewConnWithClusterAndUser creates a new connection object for a specific cluster and username.
// It returns the connection and an error, if any. | [
"NewConnWithClusterAndUser",
"creates",
"a",
"new",
"connection",
"object",
"for",
"a",
"specific",
"cluster",
"and",
"username",
".",
"It",
"returns",
"the",
"connection",
"and",
"an",
"error",
"if",
"any",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/rados.go#L71-L85 |
150,607 | ceph/go-ceph | cephfs/cephfs.go | CreateMount | func CreateMount() (*MountInfo, error) {
mount := &MountInfo{}
ret := C.ceph_create(&mount.mount, nil)
if ret != 0 {
log.Errorf("CreateMount: Failed to create mount")
return nil, cephError(ret)
}
return mount, nil
} | go | func CreateMount() (*MountInfo, error) {
mount := &MountInfo{}
ret := C.ceph_create(&mount.mount, nil)
if ret != 0 {
log.Errorf("CreateMount: Failed to create mount")
return nil, cephError(ret)
}
return mount, nil
} | [
"func",
"CreateMount",
"(",
")",
"(",
"*",
"MountInfo",
",",
"error",
")",
"{",
"mount",
":=",
"&",
"MountInfo",
"{",
"}",
"\n",
"ret",
":=",
"C",
".",
"ceph_create",
"(",
"&",
"mount",
".",
"mount",
",",
"nil",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
",",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"mount",
",",
"nil",
"\n",
"}"
] | // CreateMount creates a mount handle for interacting with Ceph. | [
"CreateMount",
"creates",
"a",
"mount",
"handle",
"for",
"interacting",
"with",
"Ceph",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L35-L43 |
150,608 | ceph/go-ceph | cephfs/cephfs.go | ReadDefaultConfigFile | func (mount *MountInfo) ReadDefaultConfigFile() error {
ret := C.ceph_conf_read_file(mount.mount, nil)
if ret != 0 {
log.Errorf("ReadDefaultConfigFile: Failed to read ceph config")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) ReadDefaultConfigFile() error {
ret := C.ceph_conf_read_file(mount.mount, nil)
if ret != 0 {
log.Errorf("ReadDefaultConfigFile: Failed to read ceph config")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"ReadDefaultConfigFile",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_conf_read_file",
"(",
"mount",
".",
"mount",
",",
"nil",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ReadDefaultConfigFile loads the ceph configuration from the specified config file. | [
"ReadDefaultConfigFile",
"loads",
"the",
"ceph",
"configuration",
"from",
"the",
"specified",
"config",
"file",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L46-L53 |
150,609 | ceph/go-ceph | cephfs/cephfs.go | Mount | func (mount *MountInfo) Mount() error {
ret := C.ceph_mount(mount.mount, nil)
if ret != 0 {
log.Errorf("Mount: Failed to mount")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) Mount() error {
ret := C.ceph_mount(mount.mount, nil)
if ret != 0 {
log.Errorf("Mount: Failed to mount")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"Mount",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_mount",
"(",
"mount",
".",
"mount",
",",
"nil",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Mount mounts the mount handle. | [
"Mount",
"mounts",
"the",
"mount",
"handle",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L56-L63 |
150,610 | ceph/go-ceph | cephfs/cephfs.go | Unmount | func (mount *MountInfo) Unmount() error {
ret := C.ceph_unmount(mount.mount)
if ret != 0 {
log.Errorf("Unmount: Failed to unmount")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) Unmount() error {
ret := C.ceph_unmount(mount.mount)
if ret != 0 {
log.Errorf("Unmount: Failed to unmount")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"Unmount",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_unmount",
"(",
"mount",
".",
"mount",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Unmount unmounts the mount handle. | [
"Unmount",
"unmounts",
"the",
"mount",
"handle",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L66-L73 |
150,611 | ceph/go-ceph | cephfs/cephfs.go | Release | func (mount *MountInfo) Release() error {
ret := C.ceph_release(mount.mount)
if ret != 0 {
log.Errorf("Release: Failed to release mount")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) Release() error {
ret := C.ceph_release(mount.mount)
if ret != 0 {
log.Errorf("Release: Failed to release mount")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"Release",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_release",
"(",
"mount",
".",
"mount",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Release destroys the mount handle. | [
"Release",
"destroys",
"the",
"mount",
"handle",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L76-L83 |
150,612 | ceph/go-ceph | cephfs/cephfs.go | SyncFs | func (mount *MountInfo) SyncFs() error {
ret := C.ceph_sync_fs(mount.mount)
if ret != 0 {
log.Errorf("Mount: Failed to sync filesystem")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) SyncFs() error {
ret := C.ceph_sync_fs(mount.mount)
if ret != 0 {
log.Errorf("Mount: Failed to sync filesystem")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"SyncFs",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_sync_fs",
"(",
"mount",
".",
"mount",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SyncFs synchronizes all filesystem data to persistent media. | [
"SyncFs",
"synchronizes",
"all",
"filesystem",
"data",
"to",
"persistent",
"media",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L86-L93 |
150,613 | ceph/go-ceph | cephfs/cephfs.go | CurrentDir | func (mount *MountInfo) CurrentDir() string {
cDir := C.ceph_getcwd(mount.mount)
return C.GoString(cDir)
} | go | func (mount *MountInfo) CurrentDir() string {
cDir := C.ceph_getcwd(mount.mount)
return C.GoString(cDir)
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"CurrentDir",
"(",
")",
"string",
"{",
"cDir",
":=",
"C",
".",
"ceph_getcwd",
"(",
"mount",
".",
"mount",
")",
"\n",
"return",
"C",
".",
"GoString",
"(",
"cDir",
")",
"\n",
"}"
] | // CurrentDir gets the current working directory. | [
"CurrentDir",
"gets",
"the",
"current",
"working",
"directory",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L96-L99 |
150,614 | ceph/go-ceph | cephfs/cephfs.go | ChangeDir | func (mount *MountInfo) ChangeDir(path string) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_chdir(mount.mount, cPath)
if ret != 0 {
log.Errorf("ChangeDir: Failed to change directory")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) ChangeDir(path string) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_chdir(mount.mount, cPath)
if ret != 0 {
log.Errorf("ChangeDir: Failed to change directory")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"ChangeDir",
"(",
"path",
"string",
")",
"error",
"{",
"cPath",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cPath",
")",
")",
"\n\n",
"ret",
":=",
"C",
".",
"ceph_chdir",
"(",
"mount",
".",
"mount",
",",
"cPath",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ChangeDir changes the current working directory. | [
"ChangeDir",
"changes",
"the",
"current",
"working",
"directory",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L102-L112 |
150,615 | ceph/go-ceph | cephfs/cephfs.go | MakeDir | func (mount *MountInfo) MakeDir(path string, mode uint32) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_mkdir(mount.mount, cPath, C.mode_t(mode))
if ret != 0 {
log.Errorf("MakeDir: Failed to make directory %s", path)
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) MakeDir(path string, mode uint32) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_mkdir(mount.mount, cPath, C.mode_t(mode))
if ret != 0 {
log.Errorf("MakeDir: Failed to make directory %s", path)
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"MakeDir",
"(",
"path",
"string",
",",
"mode",
"uint32",
")",
"error",
"{",
"cPath",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cPath",
")",
")",
"\n\n",
"ret",
":=",
"C",
".",
"ceph_mkdir",
"(",
"mount",
".",
"mount",
",",
"cPath",
",",
"C",
".",
"mode_t",
"(",
"mode",
")",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // MakeDir creates a directory. | [
"MakeDir",
"creates",
"a",
"directory",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L115-L125 |
150,616 | ceph/go-ceph | cephfs/cephfs.go | IsMounted | func (mount *MountInfo) IsMounted() bool {
ret := C.ceph_is_mounted(mount.mount)
return ret == 1
} | go | func (mount *MountInfo) IsMounted() bool {
ret := C.ceph_is_mounted(mount.mount)
return ret == 1
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"IsMounted",
"(",
")",
"bool",
"{",
"ret",
":=",
"C",
".",
"ceph_is_mounted",
"(",
"mount",
".",
"mount",
")",
"\n",
"return",
"ret",
"==",
"1",
"\n",
"}"
] | // IsMounted checks mount status. | [
"IsMounted",
"checks",
"mount",
"status",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L167-L170 |
150,617 | ceph/go-ceph | rados/conn.go | PingMonitor | func (c *Conn) PingMonitor(id string) (string, error) {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
var strlen C.size_t
var strout *C.char
ret := C.rados_ping_monitor(c.cluster, c_id, &strout, &strlen)
defer C.rados_buffer_free(strout)
if ret == 0 {
reply := C.GoStringN(strout, (C.int)(strlen))
return reply, nil
} else {
return "", RadosError(int(ret))
}
} | go | func (c *Conn) PingMonitor(id string) (string, error) {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
var strlen C.size_t
var strout *C.char
ret := C.rados_ping_monitor(c.cluster, c_id, &strout, &strlen)
defer C.rados_buffer_free(strout)
if ret == 0 {
reply := C.GoStringN(strout, (C.int)(strlen))
return reply, nil
} else {
return "", RadosError(int(ret))
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"PingMonitor",
"(",
"id",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"c_id",
":=",
"C",
".",
"CString",
"(",
"id",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_id",
")",
")",
"\n\n",
"var",
"strlen",
"C",
".",
"size_t",
"\n",
"var",
"strout",
"*",
"C",
".",
"char",
"\n\n",
"ret",
":=",
"C",
".",
"rados_ping_monitor",
"(",
"c",
".",
"cluster",
",",
"c_id",
",",
"&",
"strout",
",",
"&",
"strlen",
")",
"\n",
"defer",
"C",
".",
"rados_buffer_free",
"(",
"strout",
")",
"\n\n",
"if",
"ret",
"==",
"0",
"{",
"reply",
":=",
"C",
".",
"GoStringN",
"(",
"strout",
",",
"(",
"C",
".",
"int",
")",
"(",
"strlen",
")",
")",
"\n",
"return",
"reply",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"\"",
"\"",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] | // PingMonitor sends a ping to a monitor and returns the reply. | [
"PingMonitor",
"sends",
"a",
"ping",
"to",
"a",
"monitor",
"and",
"returns",
"the",
"reply",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L27-L43 |
150,618 | ceph/go-ceph | rados/conn.go | Connect | func (c *Conn) Connect() error {
ret := C.rados_connect(c.cluster)
if ret != 0 {
return RadosError(int(ret))
}
c.connected = true
return nil
} | go | func (c *Conn) Connect() error {
ret := C.rados_connect(c.cluster)
if ret != 0 {
return RadosError(int(ret))
}
c.connected = true
return nil
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"Connect",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"rados_connect",
"(",
"c",
".",
"cluster",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"return",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"c",
".",
"connected",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] | // Connect establishes a connection to a RADOS cluster. It returns an error,
// if any. | [
"Connect",
"establishes",
"a",
"connection",
"to",
"a",
"RADOS",
"cluster",
".",
"It",
"returns",
"an",
"error",
"if",
"any",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L47-L54 |
150,619 | ceph/go-ceph | rados/conn.go | Shutdown | func (c *Conn) Shutdown() {
if err := c.ensure_connected(); err != nil {
return
}
C.rados_shutdown(c.cluster)
} | go | func (c *Conn) Shutdown() {
if err := c.ensure_connected(); err != nil {
return
}
C.rados_shutdown(c.cluster)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"Shutdown",
"(",
")",
"{",
"if",
"err",
":=",
"c",
".",
"ensure_connected",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"C",
".",
"rados_shutdown",
"(",
"c",
".",
"cluster",
")",
"\n",
"}"
] | // Shutdown disconnects from the cluster. | [
"Shutdown",
"disconnects",
"from",
"the",
"cluster",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L57-L62 |
150,620 | ceph/go-ceph | rados/conn.go | ReadConfigFile | func (c *Conn) ReadConfigFile(path string) error {
c_path := C.CString(path)
defer C.free(unsafe.Pointer(c_path))
ret := C.rados_conf_read_file(c.cluster, c_path)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
} | go | func (c *Conn) ReadConfigFile(path string) error {
c_path := C.CString(path)
defer C.free(unsafe.Pointer(c_path))
ret := C.rados_conf_read_file(c.cluster, c_path)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"ReadConfigFile",
"(",
"path",
"string",
")",
"error",
"{",
"c_path",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_path",
")",
")",
"\n",
"ret",
":=",
"C",
".",
"rados_conf_read_file",
"(",
"c",
".",
"cluster",
",",
"c_path",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"else",
"{",
"return",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] | // ReadConfigFile configures the connection using a Ceph configuration file. | [
"ReadConfigFile",
"configures",
"the",
"connection",
"using",
"a",
"Ceph",
"configuration",
"file",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L65-L74 |
150,621 | ceph/go-ceph | rados/conn.go | ReadDefaultConfigFile | func (c *Conn) ReadDefaultConfigFile() error {
ret := C.rados_conf_read_file(c.cluster, nil)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
} | go | func (c *Conn) ReadDefaultConfigFile() error {
ret := C.rados_conf_read_file(c.cluster, nil)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"ReadDefaultConfigFile",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"rados_conf_read_file",
"(",
"c",
".",
"cluster",
",",
"nil",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"else",
"{",
"return",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] | // ReadDefaultConfigFile configures the connection using a Ceph configuration
// file located at default locations. | [
"ReadDefaultConfigFile",
"configures",
"the",
"connection",
"using",
"a",
"Ceph",
"configuration",
"file",
"located",
"at",
"default",
"locations",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L78-L85 |
150,622 | ceph/go-ceph | rados/conn.go | ListPools | func (c *Conn) ListPools() (names []string, err error) {
buf := make([]byte, 4096)
for {
ret := int(C.rados_pool_list(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
if ret < 0 {
return nil, RadosError(int(ret))
}
if ret > len(buf) {
buf = make([]byte, ret)
continue
}
tmp := bytes.SplitAfter(buf[:ret-1], []byte{0})
for _, s := range tmp {
if len(s) > 0 {
name := C.GoString((*C.char)(unsafe.Pointer(&s[0])))
names = append(names, name)
}
}
return names, nil
}
} | go | func (c *Conn) ListPools() (names []string, err error) {
buf := make([]byte, 4096)
for {
ret := int(C.rados_pool_list(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
if ret < 0 {
return nil, RadosError(int(ret))
}
if ret > len(buf) {
buf = make([]byte, ret)
continue
}
tmp := bytes.SplitAfter(buf[:ret-1], []byte{0})
for _, s := range tmp {
if len(s) > 0 {
name := C.GoString((*C.char)(unsafe.Pointer(&s[0])))
names = append(names, name)
}
}
return names, nil
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"ListPools",
"(",
")",
"(",
"names",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4096",
")",
"\n",
"for",
"{",
"ret",
":=",
"int",
"(",
"C",
".",
"rados_pool_list",
"(",
"c",
".",
"cluster",
",",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
",",
"C",
".",
"size_t",
"(",
"len",
"(",
"buf",
")",
")",
")",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n\n",
"if",
"ret",
">",
"len",
"(",
"buf",
")",
"{",
"buf",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"ret",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"tmp",
":=",
"bytes",
".",
"SplitAfter",
"(",
"buf",
"[",
":",
"ret",
"-",
"1",
"]",
",",
"[",
"]",
"byte",
"{",
"0",
"}",
")",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"tmp",
"{",
"if",
"len",
"(",
"s",
")",
">",
"0",
"{",
"name",
":=",
"C",
".",
"GoString",
"(",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"s",
"[",
"0",
"]",
")",
")",
")",
"\n",
"names",
"=",
"append",
"(",
"names",
",",
"name",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"names",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // ListPools returns the names of all existing pools. | [
"ListPools",
"returns",
"the",
"names",
"of",
"all",
"existing",
"pools",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L100-L124 |
150,623 | ceph/go-ceph | rados/conn.go | SetConfigOption | func (c *Conn) SetConfigOption(option, value string) error {
c_opt, c_val := C.CString(option), C.CString(value)
defer C.free(unsafe.Pointer(c_opt))
defer C.free(unsafe.Pointer(c_val))
ret := C.rados_conf_set(c.cluster, c_opt, c_val)
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
} | go | func (c *Conn) SetConfigOption(option, value string) error {
c_opt, c_val := C.CString(option), C.CString(value)
defer C.free(unsafe.Pointer(c_opt))
defer C.free(unsafe.Pointer(c_val))
ret := C.rados_conf_set(c.cluster, c_opt, c_val)
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"SetConfigOption",
"(",
"option",
",",
"value",
"string",
")",
"error",
"{",
"c_opt",
",",
"c_val",
":=",
"C",
".",
"CString",
"(",
"option",
")",
",",
"C",
".",
"CString",
"(",
"value",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_opt",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_val",
")",
")",
"\n",
"ret",
":=",
"C",
".",
"rados_conf_set",
"(",
"c",
".",
"cluster",
",",
"c_opt",
",",
"c_val",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"else",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // SetConfigOption sets the value of the configuration option identified by
// the given name. | [
"SetConfigOption",
"sets",
"the",
"value",
"of",
"the",
"configuration",
"option",
"identified",
"by",
"the",
"given",
"name",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L128-L138 |
150,624 | ceph/go-ceph | rados/conn.go | GetConfigOption | func (c *Conn) GetConfigOption(name string) (value string, err error) {
buf := make([]byte, 4096)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_conf_get(c.cluster, c_name,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: ret may be -ENAMETOOLONG if the buffer is not large enough. We
// can handle this case, but we need a reliable way to test for
// -ENAMETOOLONG constant. Will the syscall/Errno stuff in Go help?
if ret == 0 {
value = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return value, nil
} else {
return "", RadosError(ret)
}
} | go | func (c *Conn) GetConfigOption(name string) (value string, err error) {
buf := make([]byte, 4096)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_conf_get(c.cluster, c_name,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: ret may be -ENAMETOOLONG if the buffer is not large enough. We
// can handle this case, but we need a reliable way to test for
// -ENAMETOOLONG constant. Will the syscall/Errno stuff in Go help?
if ret == 0 {
value = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return value, nil
} else {
return "", RadosError(ret)
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"GetConfigOption",
"(",
"name",
"string",
")",
"(",
"value",
"string",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4096",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n",
"ret",
":=",
"int",
"(",
"C",
".",
"rados_conf_get",
"(",
"c",
".",
"cluster",
",",
"c_name",
",",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
",",
"C",
".",
"size_t",
"(",
"len",
"(",
"buf",
")",
")",
")",
")",
"\n",
"// FIXME: ret may be -ENAMETOOLONG if the buffer is not large enough. We",
"// can handle this case, but we need a reliable way to test for",
"// -ENAMETOOLONG constant. Will the syscall/Errno stuff in Go help?",
"if",
"ret",
"==",
"0",
"{",
"value",
"=",
"C",
".",
"GoString",
"(",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
")",
"\n",
"return",
"value",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"\"",
"\"",
",",
"RadosError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"}"
] | // GetConfigOption returns the value of the Ceph configuration option
// identified by the given name. | [
"GetConfigOption",
"returns",
"the",
"value",
"of",
"the",
"Ceph",
"configuration",
"option",
"identified",
"by",
"the",
"given",
"name",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L142-L157 |
150,625 | ceph/go-ceph | rados/conn.go | GetClusterStats | func (c *Conn) GetClusterStats() (stat ClusterStat, err error) {
if err := c.ensure_connected(); err != nil {
return ClusterStat{}, err
}
c_stat := C.struct_rados_cluster_stat_t{}
ret := C.rados_cluster_stat(c.cluster, &c_stat)
if ret < 0 {
return ClusterStat{}, RadosError(int(ret))
} else {
return ClusterStat{
Kb: uint64(c_stat.kb),
Kb_used: uint64(c_stat.kb_used),
Kb_avail: uint64(c_stat.kb_avail),
Num_objects: uint64(c_stat.num_objects),
}, nil
}
} | go | func (c *Conn) GetClusterStats() (stat ClusterStat, err error) {
if err := c.ensure_connected(); err != nil {
return ClusterStat{}, err
}
c_stat := C.struct_rados_cluster_stat_t{}
ret := C.rados_cluster_stat(c.cluster, &c_stat)
if ret < 0 {
return ClusterStat{}, RadosError(int(ret))
} else {
return ClusterStat{
Kb: uint64(c_stat.kb),
Kb_used: uint64(c_stat.kb_used),
Kb_avail: uint64(c_stat.kb_avail),
Num_objects: uint64(c_stat.num_objects),
}, nil
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"GetClusterStats",
"(",
")",
"(",
"stat",
"ClusterStat",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"ensure_connected",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"ClusterStat",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"c_stat",
":=",
"C",
".",
"struct_rados_cluster_stat_t",
"{",
"}",
"\n",
"ret",
":=",
"C",
".",
"rados_cluster_stat",
"(",
"c",
".",
"cluster",
",",
"&",
"c_stat",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"ClusterStat",
"{",
"}",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"else",
"{",
"return",
"ClusterStat",
"{",
"Kb",
":",
"uint64",
"(",
"c_stat",
".",
"kb",
")",
",",
"Kb_used",
":",
"uint64",
"(",
"c_stat",
".",
"kb_used",
")",
",",
"Kb_avail",
":",
"uint64",
"(",
"c_stat",
".",
"kb_avail",
")",
",",
"Num_objects",
":",
"uint64",
"(",
"c_stat",
".",
"num_objects",
")",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // GetClusterStat returns statistics about the cluster associated with the
// connection. | [
"GetClusterStat",
"returns",
"statistics",
"about",
"the",
"cluster",
"associated",
"with",
"the",
"connection",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L180-L196 |
150,626 | ceph/go-ceph | rados/conn.go | ParseCmdLineArgs | func (c *Conn) ParseCmdLineArgs(args []string) error {
// add an empty element 0 -- Ceph treats the array as the actual contents
// of argv and skips the first element (the executable name)
argc := C.int(len(args) + 1)
argv := make([]*C.char, argc)
// make the first element a string just in case it is ever examined
argv[0] = C.CString("placeholder")
defer C.free(unsafe.Pointer(argv[0]))
for i, arg := range args {
argv[i+1] = C.CString(arg)
defer C.free(unsafe.Pointer(argv[i+1]))
}
ret := C.rados_conf_parse_argv(c.cluster, argc, &argv[0])
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
} | go | func (c *Conn) ParseCmdLineArgs(args []string) error {
// add an empty element 0 -- Ceph treats the array as the actual contents
// of argv and skips the first element (the executable name)
argc := C.int(len(args) + 1)
argv := make([]*C.char, argc)
// make the first element a string just in case it is ever examined
argv[0] = C.CString("placeholder")
defer C.free(unsafe.Pointer(argv[0]))
for i, arg := range args {
argv[i+1] = C.CString(arg)
defer C.free(unsafe.Pointer(argv[i+1]))
}
ret := C.rados_conf_parse_argv(c.cluster, argc, &argv[0])
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"ParseCmdLineArgs",
"(",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"// add an empty element 0 -- Ceph treats the array as the actual contents",
"// of argv and skips the first element (the executable name)",
"argc",
":=",
"C",
".",
"int",
"(",
"len",
"(",
"args",
")",
"+",
"1",
")",
"\n",
"argv",
":=",
"make",
"(",
"[",
"]",
"*",
"C",
".",
"char",
",",
"argc",
")",
"\n\n",
"// make the first element a string just in case it is ever examined",
"argv",
"[",
"0",
"]",
"=",
"C",
".",
"CString",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"argv",
"[",
"0",
"]",
")",
")",
"\n\n",
"for",
"i",
",",
"arg",
":=",
"range",
"args",
"{",
"argv",
"[",
"i",
"+",
"1",
"]",
"=",
"C",
".",
"CString",
"(",
"arg",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"argv",
"[",
"i",
"+",
"1",
"]",
")",
")",
"\n",
"}",
"\n\n",
"ret",
":=",
"C",
".",
"rados_conf_parse_argv",
"(",
"c",
".",
"cluster",
",",
"argc",
",",
"&",
"argv",
"[",
"0",
"]",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"else",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // ParseCmdLineArgs configures the connection from command line arguments. | [
"ParseCmdLineArgs",
"configures",
"the",
"connection",
"from",
"command",
"line",
"arguments",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L199-L220 |
150,627 | ceph/go-ceph | rados/conn.go | GetFSID | func (c *Conn) GetFSID() (fsid string, err error) {
buf := make([]byte, 37)
ret := int(C.rados_cluster_fsid(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: the success case isn't documented correctly in librados.h
if ret == 36 {
fsid = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return fsid, nil
} else {
return "", RadosError(int(ret))
}
} | go | func (c *Conn) GetFSID() (fsid string, err error) {
buf := make([]byte, 37)
ret := int(C.rados_cluster_fsid(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: the success case isn't documented correctly in librados.h
if ret == 36 {
fsid = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return fsid, nil
} else {
return "", RadosError(int(ret))
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"GetFSID",
"(",
")",
"(",
"fsid",
"string",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"37",
")",
"\n",
"ret",
":=",
"int",
"(",
"C",
".",
"rados_cluster_fsid",
"(",
"c",
".",
"cluster",
",",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
",",
"C",
".",
"size_t",
"(",
"len",
"(",
"buf",
")",
")",
")",
")",
"\n",
"// FIXME: the success case isn't documented correctly in librados.h",
"if",
"ret",
"==",
"36",
"{",
"fsid",
"=",
"C",
".",
"GoString",
"(",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
")",
"\n",
"return",
"fsid",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"\"",
"\"",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] | // GetFSID returns the fsid of the cluster as a hexadecimal string. The fsid
// is a unique identifier of an entire Ceph cluster. | [
"GetFSID",
"returns",
"the",
"fsid",
"of",
"the",
"cluster",
"as",
"a",
"hexadecimal",
"string",
".",
"The",
"fsid",
"is",
"a",
"unique",
"identifier",
"of",
"an",
"entire",
"Ceph",
"cluster",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L235-L246 |
150,628 | ceph/go-ceph | rados/conn.go | MakePool | func (c *Conn) MakePool(name string) error {
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_create(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
} | go | func (c *Conn) MakePool(name string) error {
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_create(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"MakePool",
"(",
"name",
"string",
")",
"error",
"{",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n",
"ret",
":=",
"int",
"(",
"C",
".",
"rados_pool_create",
"(",
"c",
".",
"cluster",
",",
"c_name",
")",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"else",
"{",
"return",
"RadosError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"}"
] | // MakePool creates a new pool with default settings. | [
"MakePool",
"creates",
"a",
"new",
"pool",
"with",
"default",
"settings",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L256-L265 |
150,629 | ceph/go-ceph | rados/conn.go | DeletePool | func (c *Conn) DeletePool(name string) error {
if err := c.ensure_connected(); err != nil {
fmt.Println("NOT CONNECTED WHOOPS")
return err
}
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_delete(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
} | go | func (c *Conn) DeletePool(name string) error {
if err := c.ensure_connected(); err != nil {
fmt.Println("NOT CONNECTED WHOOPS")
return err
}
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_delete(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"DeletePool",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"c",
".",
"ensure_connected",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n",
"ret",
":=",
"int",
"(",
"C",
".",
"rados_pool_delete",
"(",
"c",
".",
"cluster",
",",
"c_name",
")",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"else",
"{",
"return",
"RadosError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"}"
] | // DeletePool deletes a pool and all the data inside the pool. | [
"DeletePool",
"deletes",
"a",
"pool",
"and",
"all",
"the",
"data",
"inside",
"the",
"pool",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L268-L281 |
150,630 | ceph/go-ceph | rados/conn.go | MonCommand | func (c *Conn) MonCommand(args []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, nil)
} | go | func (c *Conn) MonCommand(args []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, nil)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"MonCommand",
"(",
"args",
"[",
"]",
"byte",
")",
"(",
"buffer",
"[",
"]",
"byte",
",",
"info",
"string",
",",
"err",
"error",
")",
"{",
"return",
"c",
".",
"monCommand",
"(",
"args",
",",
"nil",
")",
"\n",
"}"
] | // MonCommand sends a command to one of the monitors | [
"MonCommand",
"sends",
"a",
"command",
"to",
"one",
"of",
"the",
"monitors"
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L284-L286 |
150,631 | ceph/go-ceph | rados/conn.go | MonCommandWithInputBuffer | func (c *Conn) MonCommandWithInputBuffer(args, inputBuffer []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, inputBuffer)
} | go | func (c *Conn) MonCommandWithInputBuffer(args, inputBuffer []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, inputBuffer)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"MonCommandWithInputBuffer",
"(",
"args",
",",
"inputBuffer",
"[",
"]",
"byte",
")",
"(",
"buffer",
"[",
"]",
"byte",
",",
"info",
"string",
",",
"err",
"error",
")",
"{",
"return",
"c",
".",
"monCommand",
"(",
"args",
",",
"inputBuffer",
")",
"\n",
"}"
] | // MonCommand sends a command to one of the monitors, with an input buffer | [
"MonCommand",
"sends",
"a",
"command",
"to",
"one",
"of",
"the",
"monitors",
"with",
"an",
"input",
"buffer"
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L289-L291 |
150,632 | Microsoft/go-winio | hvsock.go | VsockServiceID | func VsockServiceID(port uint32) guid.GUID {
g, _ := guid.FromString("00000000-facb-11e6-bd58-64006a7986d3")
g.Data1 = port
return *g
} | go | func VsockServiceID(port uint32) guid.GUID {
g, _ := guid.FromString("00000000-facb-11e6-bd58-64006a7986d3")
g.Data1 = port
return *g
} | [
"func",
"VsockServiceID",
"(",
"port",
"uint32",
")",
"guid",
".",
"GUID",
"{",
"g",
",",
"_",
":=",
"guid",
".",
"FromString",
"(",
"\"",
"\"",
")",
"\n",
"g",
".",
"Data1",
"=",
"port",
"\n",
"return",
"*",
"g",
"\n",
"}"
] | // VsockServiceID returns an hvsock service ID corresponding to the specified AF_VSOCK port. | [
"VsockServiceID",
"returns",
"an",
"hvsock",
"service",
"ID",
"corresponding",
"to",
"the",
"specified",
"AF_VSOCK",
"port",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L46-L50 |
150,633 | Microsoft/go-winio | hvsock.go | ListenHvsock | func ListenHvsock(addr *HvsockAddr) (_ *HvsockListener, err error) {
l := &HvsockListener{addr: *addr}
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("listen", err)
}
sa := addr.raw()
err = bind(sock.handle, unsafe.Pointer(&sa), int32(unsafe.Sizeof(sa)))
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("socket", err))
}
err = syscall.Listen(sock.handle, 16)
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("listen", err))
}
return &HvsockListener{sock: sock, addr: *addr}, nil
} | go | func ListenHvsock(addr *HvsockAddr) (_ *HvsockListener, err error) {
l := &HvsockListener{addr: *addr}
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("listen", err)
}
sa := addr.raw()
err = bind(sock.handle, unsafe.Pointer(&sa), int32(unsafe.Sizeof(sa)))
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("socket", err))
}
err = syscall.Listen(sock.handle, 16)
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("listen", err))
}
return &HvsockListener{sock: sock, addr: *addr}, nil
} | [
"func",
"ListenHvsock",
"(",
"addr",
"*",
"HvsockAddr",
")",
"(",
"_",
"*",
"HvsockListener",
",",
"err",
"error",
")",
"{",
"l",
":=",
"&",
"HvsockListener",
"{",
"addr",
":",
"*",
"addr",
"}",
"\n",
"sock",
",",
"err",
":=",
"newHvSocket",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"sa",
":=",
"addr",
".",
"raw",
"(",
")",
"\n",
"err",
"=",
"bind",
"(",
"sock",
".",
"handle",
",",
"unsafe",
".",
"Pointer",
"(",
"&",
"sa",
")",
",",
"int32",
"(",
"unsafe",
".",
"Sizeof",
"(",
"sa",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"err",
"=",
"syscall",
".",
"Listen",
"(",
"sock",
".",
"handle",
",",
"16",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"&",
"HvsockListener",
"{",
"sock",
":",
"sock",
",",
"addr",
":",
"*",
"addr",
"}",
",",
"nil",
"\n",
"}"
] | // ListenHvsock listens for connections on the specified hvsock address. | [
"ListenHvsock",
"listens",
"for",
"connections",
"on",
"the",
"specified",
"hvsock",
"address",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L92-L108 |
150,634 | Microsoft/go-winio | hvsock.go | Accept | func (l *HvsockListener) Accept() (_ net.Conn, err error) {
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("accept", err)
}
defer func() {
if sock != nil {
sock.Close()
}
}()
c, err := l.sock.prepareIo()
if err != nil {
return nil, l.opErr("accept", err)
}
defer l.sock.wg.Done()
// AcceptEx, per documentation, requires an extra 16 bytes per address.
const addrlen = uint32(16 + unsafe.Sizeof(rawHvsockAddr{}))
var addrbuf [addrlen * 2]byte
var bytes uint32
err = syscall.AcceptEx(l.sock.handle, sock.handle, &addrbuf[0], 0, addrlen, addrlen, &bytes, &c.o)
_, err = l.sock.asyncIo(c, nil, bytes, err)
if err != nil {
return nil, l.opErr("accept", os.NewSyscallError("acceptex", err))
}
conn := &HvsockConn{
sock: sock,
}
conn.local.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[0])))
conn.remote.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[addrlen])))
sock = nil
return conn, nil
} | go | func (l *HvsockListener) Accept() (_ net.Conn, err error) {
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("accept", err)
}
defer func() {
if sock != nil {
sock.Close()
}
}()
c, err := l.sock.prepareIo()
if err != nil {
return nil, l.opErr("accept", err)
}
defer l.sock.wg.Done()
// AcceptEx, per documentation, requires an extra 16 bytes per address.
const addrlen = uint32(16 + unsafe.Sizeof(rawHvsockAddr{}))
var addrbuf [addrlen * 2]byte
var bytes uint32
err = syscall.AcceptEx(l.sock.handle, sock.handle, &addrbuf[0], 0, addrlen, addrlen, &bytes, &c.o)
_, err = l.sock.asyncIo(c, nil, bytes, err)
if err != nil {
return nil, l.opErr("accept", os.NewSyscallError("acceptex", err))
}
conn := &HvsockConn{
sock: sock,
}
conn.local.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[0])))
conn.remote.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[addrlen])))
sock = nil
return conn, nil
} | [
"func",
"(",
"l",
"*",
"HvsockListener",
")",
"Accept",
"(",
")",
"(",
"_",
"net",
".",
"Conn",
",",
"err",
"error",
")",
"{",
"sock",
",",
"err",
":=",
"newHvSocket",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"if",
"sock",
"!=",
"nil",
"{",
"sock",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"c",
",",
"err",
":=",
"l",
".",
"sock",
".",
"prepareIo",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"l",
".",
"sock",
".",
"wg",
".",
"Done",
"(",
")",
"\n\n",
"// AcceptEx, per documentation, requires an extra 16 bytes per address.",
"const",
"addrlen",
"=",
"uint32",
"(",
"16",
"+",
"unsafe",
".",
"Sizeof",
"(",
"rawHvsockAddr",
"{",
"}",
")",
")",
"\n",
"var",
"addrbuf",
"[",
"addrlen",
"*",
"2",
"]",
"byte",
"\n\n",
"var",
"bytes",
"uint32",
"\n",
"err",
"=",
"syscall",
".",
"AcceptEx",
"(",
"l",
".",
"sock",
".",
"handle",
",",
"sock",
".",
"handle",
",",
"&",
"addrbuf",
"[",
"0",
"]",
",",
"0",
",",
"addrlen",
",",
"addrlen",
",",
"&",
"bytes",
",",
"&",
"c",
".",
"o",
")",
"\n",
"_",
",",
"err",
"=",
"l",
".",
"sock",
".",
"asyncIo",
"(",
"c",
",",
"nil",
",",
"bytes",
",",
"err",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"conn",
":=",
"&",
"HvsockConn",
"{",
"sock",
":",
"sock",
",",
"}",
"\n",
"conn",
".",
"local",
".",
"fromRaw",
"(",
"(",
"*",
"rawHvsockAddr",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"addrbuf",
"[",
"0",
"]",
")",
")",
")",
"\n",
"conn",
".",
"remote",
".",
"fromRaw",
"(",
"(",
"*",
"rawHvsockAddr",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"addrbuf",
"[",
"addrlen",
"]",
")",
")",
")",
"\n",
"sock",
"=",
"nil",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] | // Accept waits for the next connection and returns it. | [
"Accept",
"waits",
"for",
"the",
"next",
"connection",
"and",
"returns",
"it",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L120-L153 |
150,635 | Microsoft/go-winio | hvsock.go | CloseRead | func (conn *HvsockConn) CloseRead() error {
err := conn.shutdown(syscall.SHUT_RD)
if err != nil {
return conn.opErr("close", err)
}
return nil
} | go | func (conn *HvsockConn) CloseRead() error {
err := conn.shutdown(syscall.SHUT_RD)
if err != nil {
return conn.opErr("close", err)
}
return nil
} | [
"func",
"(",
"conn",
"*",
"HvsockConn",
")",
"CloseRead",
"(",
")",
"error",
"{",
"err",
":=",
"conn",
".",
"shutdown",
"(",
"syscall",
".",
"SHUT_RD",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"conn",
".",
"opErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CloseRead shuts down the read end of the socket. | [
"CloseRead",
"shuts",
"down",
"the",
"read",
"end",
"of",
"the",
"socket",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L262-L268 |
150,636 | Microsoft/go-winio | hvsock.go | CloseWrite | func (conn *HvsockConn) CloseWrite() error {
err := conn.shutdown(syscall.SHUT_WR)
if err != nil {
return conn.opErr("close", err)
}
return nil
} | go | func (conn *HvsockConn) CloseWrite() error {
err := conn.shutdown(syscall.SHUT_WR)
if err != nil {
return conn.opErr("close", err)
}
return nil
} | [
"func",
"(",
"conn",
"*",
"HvsockConn",
")",
"CloseWrite",
"(",
")",
"error",
"{",
"err",
":=",
"conn",
".",
"shutdown",
"(",
"syscall",
".",
"SHUT_WR",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"conn",
".",
"opErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CloseWrite shuts down the write end of the socket, notifying the other endpoint that
// no more data will be written. | [
"CloseWrite",
"shuts",
"down",
"the",
"write",
"end",
"of",
"the",
"socket",
"notifying",
"the",
"other",
"endpoint",
"that",
"no",
"more",
"data",
"will",
"be",
"written",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L272-L278 |
150,637 | Microsoft/go-winio | ea.go | DecodeExtendedAttributes | func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
for len(b) != 0 {
ea, nb, err := parseEa(b)
if err != nil {
return nil, err
}
eas = append(eas, ea)
b = nb
}
return
} | go | func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
for len(b) != 0 {
ea, nb, err := parseEa(b)
if err != nil {
return nil, err
}
eas = append(eas, ea)
b = nb
}
return
} | [
"func",
"DecodeExtendedAttributes",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"eas",
"[",
"]",
"ExtendedAttribute",
",",
"err",
"error",
")",
"{",
"for",
"len",
"(",
"b",
")",
"!=",
"0",
"{",
"ea",
",",
"nb",
",",
"err",
":=",
"parseEa",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"eas",
"=",
"append",
"(",
"eas",
",",
"ea",
")",
"\n",
"b",
"=",
"nb",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // DecodeExtendedAttributes decodes a list of EAs from a FILE_FULL_EA_INFORMATION
// buffer retrieved from BackupRead, ZwQueryEaFile, etc. | [
"DecodeExtendedAttributes",
"decodes",
"a",
"list",
"of",
"EAs",
"from",
"a",
"FILE_FULL_EA_INFORMATION",
"buffer",
"retrieved",
"from",
"BackupRead",
"ZwQueryEaFile",
"etc",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/ea.go#L60-L71 |
150,638 | Microsoft/go-winio | ea.go | EncodeExtendedAttributes | func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
var buf bytes.Buffer
for i := range eas {
last := false
if i == len(eas)-1 {
last = true
}
err := writeEa(&buf, &eas[i], last)
if err != nil {
return nil, err
}
}
return buf.Bytes(), nil
} | go | func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
var buf bytes.Buffer
for i := range eas {
last := false
if i == len(eas)-1 {
last = true
}
err := writeEa(&buf, &eas[i], last)
if err != nil {
return nil, err
}
}
return buf.Bytes(), nil
} | [
"func",
"EncodeExtendedAttributes",
"(",
"eas",
"[",
"]",
"ExtendedAttribute",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"for",
"i",
":=",
"range",
"eas",
"{",
"last",
":=",
"false",
"\n",
"if",
"i",
"==",
"len",
"(",
"eas",
")",
"-",
"1",
"{",
"last",
"=",
"true",
"\n",
"}",
"\n\n",
"err",
":=",
"writeEa",
"(",
"&",
"buf",
",",
"&",
"eas",
"[",
"i",
"]",
",",
"last",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"buf",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
] | // EncodeExtendedAttributes encodes a list of EAs into a FILE_FULL_EA_INFORMATION
// buffer for use with BackupWrite, ZwSetEaFile, etc. | [
"EncodeExtendedAttributes",
"encodes",
"a",
"list",
"of",
"EAs",
"into",
"a",
"FILE_FULL_EA_INFORMATION",
"buffer",
"for",
"use",
"with",
"BackupWrite",
"ZwSetEaFile",
"etc",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/ea.go#L123-L137 |
150,639 | Microsoft/go-winio | reparse.go | DecodeReparsePoint | func DecodeReparsePoint(b []byte) (*ReparsePoint, error) {
tag := binary.LittleEndian.Uint32(b[0:4])
return DecodeReparsePointData(tag, b[8:])
} | go | func DecodeReparsePoint(b []byte) (*ReparsePoint, error) {
tag := binary.LittleEndian.Uint32(b[0:4])
return DecodeReparsePointData(tag, b[8:])
} | [
"func",
"DecodeReparsePoint",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"*",
"ReparsePoint",
",",
"error",
")",
"{",
"tag",
":=",
"binary",
".",
"LittleEndian",
".",
"Uint32",
"(",
"b",
"[",
"0",
":",
"4",
"]",
")",
"\n",
"return",
"DecodeReparsePointData",
"(",
"tag",
",",
"b",
"[",
"8",
":",
"]",
")",
"\n",
"}"
] | // DecodeReparsePoint decodes a Win32 REPARSE_DATA_BUFFER structure containing either a symlink
// or a mount point. | [
"DecodeReparsePoint",
"decodes",
"a",
"Win32",
"REPARSE_DATA_BUFFER",
"structure",
"containing",
"either",
"a",
"symlink",
"or",
"a",
"mount",
"point",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/reparse.go#L45-L48 |
150,640 | Microsoft/go-winio | reparse.go | EncodeReparsePoint | func EncodeReparsePoint(rp *ReparsePoint) []byte {
// Generate an NT path and determine if this is a relative path.
var ntTarget string
relative := false
if strings.HasPrefix(rp.Target, `\\?\`) {
ntTarget = `\??\` + rp.Target[4:]
} else if strings.HasPrefix(rp.Target, `\\`) {
ntTarget = `\??\UNC\` + rp.Target[2:]
} else if len(rp.Target) >= 2 && isDriveLetter(rp.Target[0]) && rp.Target[1] == ':' {
ntTarget = `\??\` + rp.Target
} else {
ntTarget = rp.Target
relative = true
}
// The paths must be NUL-terminated even though they are counted strings.
target16 := utf16.Encode([]rune(rp.Target + "\x00"))
ntTarget16 := utf16.Encode([]rune(ntTarget + "\x00"))
size := int(unsafe.Sizeof(reparseDataBuffer{})) - 8
size += len(ntTarget16)*2 + len(target16)*2
tag := uint32(reparseTagMountPoint)
if !rp.IsMountPoint {
tag = reparseTagSymlink
size += 4 // Add room for symlink flags
}
data := reparseDataBuffer{
ReparseTag: tag,
ReparseDataLength: uint16(size),
SubstituteNameOffset: 0,
SubstituteNameLength: uint16((len(ntTarget16) - 1) * 2),
PrintNameOffset: uint16(len(ntTarget16) * 2),
PrintNameLength: uint16((len(target16) - 1) * 2),
}
var b bytes.Buffer
binary.Write(&b, binary.LittleEndian, &data)
if !rp.IsMountPoint {
flags := uint32(0)
if relative {
flags |= 1
}
binary.Write(&b, binary.LittleEndian, flags)
}
binary.Write(&b, binary.LittleEndian, ntTarget16)
binary.Write(&b, binary.LittleEndian, target16)
return b.Bytes()
} | go | func EncodeReparsePoint(rp *ReparsePoint) []byte {
// Generate an NT path and determine if this is a relative path.
var ntTarget string
relative := false
if strings.HasPrefix(rp.Target, `\\?\`) {
ntTarget = `\??\` + rp.Target[4:]
} else if strings.HasPrefix(rp.Target, `\\`) {
ntTarget = `\??\UNC\` + rp.Target[2:]
} else if len(rp.Target) >= 2 && isDriveLetter(rp.Target[0]) && rp.Target[1] == ':' {
ntTarget = `\??\` + rp.Target
} else {
ntTarget = rp.Target
relative = true
}
// The paths must be NUL-terminated even though they are counted strings.
target16 := utf16.Encode([]rune(rp.Target + "\x00"))
ntTarget16 := utf16.Encode([]rune(ntTarget + "\x00"))
size := int(unsafe.Sizeof(reparseDataBuffer{})) - 8
size += len(ntTarget16)*2 + len(target16)*2
tag := uint32(reparseTagMountPoint)
if !rp.IsMountPoint {
tag = reparseTagSymlink
size += 4 // Add room for symlink flags
}
data := reparseDataBuffer{
ReparseTag: tag,
ReparseDataLength: uint16(size),
SubstituteNameOffset: 0,
SubstituteNameLength: uint16((len(ntTarget16) - 1) * 2),
PrintNameOffset: uint16(len(ntTarget16) * 2),
PrintNameLength: uint16((len(target16) - 1) * 2),
}
var b bytes.Buffer
binary.Write(&b, binary.LittleEndian, &data)
if !rp.IsMountPoint {
flags := uint32(0)
if relative {
flags |= 1
}
binary.Write(&b, binary.LittleEndian, flags)
}
binary.Write(&b, binary.LittleEndian, ntTarget16)
binary.Write(&b, binary.LittleEndian, target16)
return b.Bytes()
} | [
"func",
"EncodeReparsePoint",
"(",
"rp",
"*",
"ReparsePoint",
")",
"[",
"]",
"byte",
"{",
"// Generate an NT path and determine if this is a relative path.",
"var",
"ntTarget",
"string",
"\n",
"relative",
":=",
"false",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"rp",
".",
"Target",
",",
"`\\\\?\\`",
")",
"{",
"ntTarget",
"=",
"`\\??\\`",
"+",
"rp",
".",
"Target",
"[",
"4",
":",
"]",
"\n",
"}",
"else",
"if",
"strings",
".",
"HasPrefix",
"(",
"rp",
".",
"Target",
",",
"`\\\\`",
")",
"{",
"ntTarget",
"=",
"`\\??\\UNC\\`",
"+",
"rp",
".",
"Target",
"[",
"2",
":",
"]",
"\n",
"}",
"else",
"if",
"len",
"(",
"rp",
".",
"Target",
")",
">=",
"2",
"&&",
"isDriveLetter",
"(",
"rp",
".",
"Target",
"[",
"0",
"]",
")",
"&&",
"rp",
".",
"Target",
"[",
"1",
"]",
"==",
"':'",
"{",
"ntTarget",
"=",
"`\\??\\`",
"+",
"rp",
".",
"Target",
"\n",
"}",
"else",
"{",
"ntTarget",
"=",
"rp",
".",
"Target",
"\n",
"relative",
"=",
"true",
"\n",
"}",
"\n\n",
"// The paths must be NUL-terminated even though they are counted strings.",
"target16",
":=",
"utf16",
".",
"Encode",
"(",
"[",
"]",
"rune",
"(",
"rp",
".",
"Target",
"+",
"\"",
"\\x00",
"\"",
")",
")",
"\n",
"ntTarget16",
":=",
"utf16",
".",
"Encode",
"(",
"[",
"]",
"rune",
"(",
"ntTarget",
"+",
"\"",
"\\x00",
"\"",
")",
")",
"\n\n",
"size",
":=",
"int",
"(",
"unsafe",
".",
"Sizeof",
"(",
"reparseDataBuffer",
"{",
"}",
")",
")",
"-",
"8",
"\n",
"size",
"+=",
"len",
"(",
"ntTarget16",
")",
"*",
"2",
"+",
"len",
"(",
"target16",
")",
"*",
"2",
"\n\n",
"tag",
":=",
"uint32",
"(",
"reparseTagMountPoint",
")",
"\n",
"if",
"!",
"rp",
".",
"IsMountPoint",
"{",
"tag",
"=",
"reparseTagSymlink",
"\n",
"size",
"+=",
"4",
"// Add room for symlink flags",
"\n",
"}",
"\n\n",
"data",
":=",
"reparseDataBuffer",
"{",
"ReparseTag",
":",
"tag",
",",
"ReparseDataLength",
":",
"uint16",
"(",
"size",
")",
",",
"SubstituteNameOffset",
":",
"0",
",",
"SubstituteNameLength",
":",
"uint16",
"(",
"(",
"len",
"(",
"ntTarget16",
")",
"-",
"1",
")",
"*",
"2",
")",
",",
"PrintNameOffset",
":",
"uint16",
"(",
"len",
"(",
"ntTarget16",
")",
"*",
"2",
")",
",",
"PrintNameLength",
":",
"uint16",
"(",
"(",
"len",
"(",
"target16",
")",
"-",
"1",
")",
"*",
"2",
")",
",",
"}",
"\n\n",
"var",
"b",
"bytes",
".",
"Buffer",
"\n",
"binary",
".",
"Write",
"(",
"&",
"b",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"data",
")",
"\n",
"if",
"!",
"rp",
".",
"IsMountPoint",
"{",
"flags",
":=",
"uint32",
"(",
"0",
")",
"\n",
"if",
"relative",
"{",
"flags",
"|=",
"1",
"\n",
"}",
"\n",
"binary",
".",
"Write",
"(",
"&",
"b",
",",
"binary",
".",
"LittleEndian",
",",
"flags",
")",
"\n",
"}",
"\n\n",
"binary",
".",
"Write",
"(",
"&",
"b",
",",
"binary",
".",
"LittleEndian",
",",
"ntTarget16",
")",
"\n",
"binary",
".",
"Write",
"(",
"&",
"b",
",",
"binary",
".",
"LittleEndian",
",",
"target16",
")",
"\n",
"return",
"b",
".",
"Bytes",
"(",
")",
"\n",
"}"
] | // EncodeReparsePoint encodes a Win32 REPARSE_DATA_BUFFER structure describing a symlink or
// mount point. | [
"EncodeReparsePoint",
"encodes",
"a",
"Win32",
"REPARSE_DATA_BUFFER",
"structure",
"describing",
"a",
"symlink",
"or",
"mount",
"point",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/reparse.go#L78-L128 |
150,641 | Microsoft/go-winio | pkg/etw/fieldopt.go | BoolField | func BoolField(name string, value bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeBoolean, 0)
bool8 := uint8(0)
if value {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
} | go | func BoolField(name string, value bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeBoolean, 0)
bool8 := uint8(0)
if value {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
} | [
"func",
"BoolField",
"(",
"name",
"string",
",",
"value",
"bool",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint8",
",",
"outTypeBoolean",
",",
"0",
")",
"\n",
"bool8",
":=",
"uint8",
"(",
"0",
")",
"\n",
"if",
"value",
"{",
"bool8",
"=",
"uint8",
"(",
"1",
")",
"\n",
"}",
"\n",
"ed",
".",
"writeUint8",
"(",
"bool8",
")",
"\n",
"}",
"\n",
"}"
] | // BoolField adds a single bool field to the event. | [
"BoolField",
"adds",
"a",
"single",
"bool",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L20-L29 |
150,642 | Microsoft/go-winio | pkg/etw/fieldopt.go | BoolArray | func BoolArray(name string, values []bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeBoolean, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
bool8 := uint8(0)
if v {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
}
} | go | func BoolArray(name string, values []bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeBoolean, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
bool8 := uint8(0)
if v {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
}
} | [
"func",
"BoolArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"bool",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint8",
",",
"outTypeBoolean",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"bool8",
":=",
"uint8",
"(",
"0",
")",
"\n",
"if",
"v",
"{",
"bool8",
"=",
"uint8",
"(",
"1",
")",
"\n",
"}",
"\n",
"ed",
".",
"writeUint8",
"(",
"bool8",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // BoolArray adds an array of bool to the event. | [
"BoolArray",
"adds",
"an",
"array",
"of",
"bool",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L32-L44 |
150,643 | Microsoft/go-winio | pkg/etw/fieldopt.go | StringField | func StringField(name string, value string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeString(value)
}
} | go | func StringField(name string, value string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeString(value)
}
} | [
"func",
"StringField",
"(",
"name",
"string",
",",
"value",
"string",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeANSIString",
",",
"outTypeUTF8",
",",
"0",
")",
"\n",
"ed",
".",
"writeString",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // StringField adds a single string field to the event. | [
"StringField",
"adds",
"a",
"single",
"string",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L47-L52 |
150,644 | Microsoft/go-winio | pkg/etw/fieldopt.go | StringArray | func StringArray(name string, values []string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeString(v)
}
}
} | go | func StringArray(name string, values []string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeString(v)
}
}
} | [
"func",
"StringArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"string",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeANSIString",
",",
"outTypeUTF8",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeString",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // StringArray adds an array of string to the event. | [
"StringArray",
"adds",
"an",
"array",
"of",
"string",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L55-L63 |
150,645 | Microsoft/go-winio | pkg/etw/fieldopt.go | IntField | func IntField(name string, value int) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Int32Field(name, int32(value))
case 8:
return Int64Field(name, int64(value))
default:
panic("Unsupported int size")
}
} | go | func IntField(name string, value int) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Int32Field(name, int32(value))
case 8:
return Int64Field(name, int64(value))
default:
panic("Unsupported int size")
}
} | [
"func",
"IntField",
"(",
"name",
"string",
",",
"value",
"int",
")",
"FieldOpt",
"{",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"value",
")",
"{",
"case",
"4",
":",
"return",
"Int32Field",
"(",
"name",
",",
"int32",
"(",
"value",
")",
")",
"\n",
"case",
"8",
":",
"return",
"Int64Field",
"(",
"name",
",",
"int64",
"(",
"value",
")",
")",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // IntField adds a single int field to the event. | [
"IntField",
"adds",
"a",
"single",
"int",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L66-L75 |
150,646 | Microsoft/go-winio | pkg/etw/fieldopt.go | IntArray | func IntArray(name string, values []int) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, int)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeInt32
writeItem = func(ed *eventData, item int) { ed.writeInt32(int32(item)) }
case 8:
inType = inTypeInt64
writeItem = func(ed *eventData, item int) { ed.writeInt64(int64(item)) }
default:
panic("Unsupported int size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | go | func IntArray(name string, values []int) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, int)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeInt32
writeItem = func(ed *eventData, item int) { ed.writeInt32(int32(item)) }
case 8:
inType = inTypeInt64
writeItem = func(ed *eventData, item int) { ed.writeInt64(int64(item)) }
default:
panic("Unsupported int size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | [
"func",
"IntArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"int",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"values",
"[",
"0",
"]",
")",
"{",
"case",
"4",
":",
"inType",
"=",
"inTypeInt32",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"int",
")",
"{",
"ed",
".",
"writeInt32",
"(",
"int32",
"(",
"item",
")",
")",
"}",
"\n",
"case",
"8",
":",
"inType",
"=",
"inTypeInt64",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"int",
")",
"{",
"ed",
".",
"writeInt64",
"(",
"int64",
"(",
"item",
")",
")",
"}",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inType",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"writeItem",
"(",
"ed",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // IntArray adds an array of int to the event. | [
"IntArray",
"adds",
"an",
"array",
"of",
"int",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L78-L99 |
150,647 | Microsoft/go-winio | pkg/etw/fieldopt.go | Int8Field | func Int8Field(name string, value int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt8, outTypeDefault, 0)
ed.writeInt8(value)
}
} | go | func Int8Field(name string, value int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt8, outTypeDefault, 0)
ed.writeInt8(value)
}
} | [
"func",
"Int8Field",
"(",
"name",
"string",
",",
"value",
"int8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt8",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeInt8",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // Int8Field adds a single int8 field to the event. | [
"Int8Field",
"adds",
"a",
"single",
"int8",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L102-L107 |
150,648 | Microsoft/go-winio | pkg/etw/fieldopt.go | Int8Array | func Int8Array(name string, values []int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt8(v)
}
}
} | go | func Int8Array(name string, values []int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt8(v)
}
}
} | [
"func",
"Int8Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt8",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeInt8",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Int8Array adds an array of int8 to the event. | [
"Int8Array",
"adds",
"an",
"array",
"of",
"int8",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L110-L118 |
150,649 | Microsoft/go-winio | pkg/etw/fieldopt.go | Int16Field | func Int16Field(name string, value int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt16, outTypeDefault, 0)
ed.writeInt16(value)
}
} | go | func Int16Field(name string, value int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt16, outTypeDefault, 0)
ed.writeInt16(value)
}
} | [
"func",
"Int16Field",
"(",
"name",
"string",
",",
"value",
"int16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt16",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeInt16",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // Int16Field adds a single int16 field to the event. | [
"Int16Field",
"adds",
"a",
"single",
"int16",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L121-L126 |
150,650 | Microsoft/go-winio | pkg/etw/fieldopt.go | Int16Array | func Int16Array(name string, values []int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt16(v)
}
}
} | go | func Int16Array(name string, values []int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt16(v)
}
}
} | [
"func",
"Int16Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt16",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeInt16",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Int16Array adds an array of int16 to the event. | [
"Int16Array",
"adds",
"an",
"array",
"of",
"int16",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L129-L137 |
150,651 | Microsoft/go-winio | pkg/etw/fieldopt.go | Int32Field | func Int32Field(name string, value int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt32, outTypeDefault, 0)
ed.writeInt32(value)
}
} | go | func Int32Field(name string, value int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt32, outTypeDefault, 0)
ed.writeInt32(value)
}
} | [
"func",
"Int32Field",
"(",
"name",
"string",
",",
"value",
"int32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt32",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeInt32",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // Int32Field adds a single int32 field to the event. | [
"Int32Field",
"adds",
"a",
"single",
"int32",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L140-L145 |
150,652 | Microsoft/go-winio | pkg/etw/fieldopt.go | Int32Array | func Int32Array(name string, values []int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt32(v)
}
}
} | go | func Int32Array(name string, values []int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt32(v)
}
}
} | [
"func",
"Int32Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt32",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeInt32",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Int32Array adds an array of int32 to the event. | [
"Int32Array",
"adds",
"an",
"array",
"of",
"int32",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L148-L156 |
150,653 | Microsoft/go-winio | pkg/etw/fieldopt.go | Int64Field | func Int64Field(name string, value int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt64, outTypeDefault, 0)
ed.writeInt64(value)
}
} | go | func Int64Field(name string, value int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt64, outTypeDefault, 0)
ed.writeInt64(value)
}
} | [
"func",
"Int64Field",
"(",
"name",
"string",
",",
"value",
"int64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt64",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeInt64",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // Int64Field adds a single int64 field to the event. | [
"Int64Field",
"adds",
"a",
"single",
"int64",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L159-L164 |
150,654 | Microsoft/go-winio | pkg/etw/fieldopt.go | Int64Array | func Int64Array(name string, values []int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt64(v)
}
}
} | go | func Int64Array(name string, values []int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt64(v)
}
}
} | [
"func",
"Int64Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt64",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeInt64",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Int64Array adds an array of int64 to the event. | [
"Int64Array",
"adds",
"an",
"array",
"of",
"int64",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L167-L175 |
150,655 | Microsoft/go-winio | pkg/etw/fieldopt.go | UintField | func UintField(name string, value uint) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Uint32Field(name, uint32(value))
case 8:
return Uint64Field(name, uint64(value))
default:
panic("Unsupported uint size")
}
} | go | func UintField(name string, value uint) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Uint32Field(name, uint32(value))
case 8:
return Uint64Field(name, uint64(value))
default:
panic("Unsupported uint size")
}
} | [
"func",
"UintField",
"(",
"name",
"string",
",",
"value",
"uint",
")",
"FieldOpt",
"{",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"value",
")",
"{",
"case",
"4",
":",
"return",
"Uint32Field",
"(",
"name",
",",
"uint32",
"(",
"value",
")",
")",
"\n",
"case",
"8",
":",
"return",
"Uint64Field",
"(",
"name",
",",
"uint64",
"(",
"value",
")",
")",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // UintField adds a single uint field to the event. | [
"UintField",
"adds",
"a",
"single",
"uint",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L178-L187 |
150,656 | Microsoft/go-winio | pkg/etw/fieldopt.go | UintArray | func UintArray(name string, values []uint) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uint)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeUint32
writeItem = func(ed *eventData, item uint) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeUint64
writeItem = func(ed *eventData, item uint) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uint size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | go | func UintArray(name string, values []uint) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uint)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeUint32
writeItem = func(ed *eventData, item uint) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeUint64
writeItem = func(ed *eventData, item uint) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uint size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | [
"func",
"UintArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"uint",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"values",
"[",
"0",
"]",
")",
"{",
"case",
"4",
":",
"inType",
"=",
"inTypeUint32",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uint",
")",
"{",
"ed",
".",
"writeUint32",
"(",
"uint32",
"(",
"item",
")",
")",
"}",
"\n",
"case",
"8",
":",
"inType",
"=",
"inTypeUint64",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uint",
")",
"{",
"ed",
".",
"writeUint64",
"(",
"uint64",
"(",
"item",
")",
")",
"}",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inType",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"writeItem",
"(",
"ed",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // UintArray adds an array of uint to the event. | [
"UintArray",
"adds",
"an",
"array",
"of",
"uint",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L190-L211 |
150,657 | Microsoft/go-winio | pkg/etw/fieldopt.go | Uint8Field | func Uint8Field(name string, value uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint8(value)
}
} | go | func Uint8Field(name string, value uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint8(value)
}
} | [
"func",
"Uint8Field",
"(",
"name",
"string",
",",
"value",
"uint8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint8",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint8",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // Uint8Field adds a single uint8 field to the event. | [
"Uint8Field",
"adds",
"a",
"single",
"uint8",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L214-L219 |
150,658 | Microsoft/go-winio | pkg/etw/fieldopt.go | Uint8Array | func Uint8Array(name string, values []uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint8(v)
}
}
} | go | func Uint8Array(name string, values []uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint8(v)
}
}
} | [
"func",
"Uint8Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint8",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint8",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Uint8Array adds an array of uint8 to the event. | [
"Uint8Array",
"adds",
"an",
"array",
"of",
"uint8",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L222-L230 |
150,659 | Microsoft/go-winio | pkg/etw/fieldopt.go | Uint16Field | func Uint16Field(name string, value uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(value)
}
} | go | func Uint16Field(name string, value uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(value)
}
} | [
"func",
"Uint16Field",
"(",
"name",
"string",
",",
"value",
"uint16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint16",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // Uint16Field adds a single uint16 field to the event. | [
"Uint16Field",
"adds",
"a",
"single",
"uint16",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L233-L238 |
150,660 | Microsoft/go-winio | pkg/etw/fieldopt.go | Uint16Array | func Uint16Array(name string, values []uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint16(v)
}
}
} | go | func Uint16Array(name string, values []uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint16(v)
}
}
} | [
"func",
"Uint16Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint16",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint16",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Uint16Array adds an array of uint16 to the event. | [
"Uint16Array",
"adds",
"an",
"array",
"of",
"uint16",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L241-L249 |
150,661 | Microsoft/go-winio | pkg/etw/fieldopt.go | Uint32Field | func Uint32Field(name string, value uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint32(value)
}
} | go | func Uint32Field(name string, value uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint32(value)
}
} | [
"func",
"Uint32Field",
"(",
"name",
"string",
",",
"value",
"uint32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint32",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint32",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // Uint32Field adds a single uint32 field to the event. | [
"Uint32Field",
"adds",
"a",
"single",
"uint32",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L252-L257 |
150,662 | Microsoft/go-winio | pkg/etw/fieldopt.go | Uint32Array | func Uint32Array(name string, values []uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(v)
}
}
} | go | func Uint32Array(name string, values []uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(v)
}
}
} | [
"func",
"Uint32Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint32",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint32",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Uint32Array adds an array of uint32 to the event. | [
"Uint32Array",
"adds",
"an",
"array",
"of",
"uint32",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L260-L268 |
150,663 | Microsoft/go-winio | pkg/etw/fieldopt.go | Uint64Field | func Uint64Field(name string, value uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint64(value)
}
} | go | func Uint64Field(name string, value uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint64(value)
}
} | [
"func",
"Uint64Field",
"(",
"name",
"string",
",",
"value",
"uint64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint64",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint64",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // Uint64Field adds a single uint64 field to the event. | [
"Uint64Field",
"adds",
"a",
"single",
"uint64",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L271-L276 |
150,664 | Microsoft/go-winio | pkg/etw/fieldopt.go | Uint64Array | func Uint64Array(name string, values []uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(v)
}
}
} | go | func Uint64Array(name string, values []uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(v)
}
}
} | [
"func",
"Uint64Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint64",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint64",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Uint64Array adds an array of uint64 to the event. | [
"Uint64Array",
"adds",
"an",
"array",
"of",
"uint64",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L279-L287 |
150,665 | Microsoft/go-winio | pkg/etw/fieldopt.go | UintptrField | func UintptrField(name string, value uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(value) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inType, outTypeDefault, 0)
writeItem(ed, value)
}
} | go | func UintptrField(name string, value uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(value) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inType, outTypeDefault, 0)
writeItem(ed, value)
}
} | [
"func",
"UintptrField",
"(",
"name",
"string",
",",
"value",
"uintptr",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"uintptr",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"value",
")",
"{",
"case",
"4",
":",
"inType",
"=",
"inTypeHexInt32",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uintptr",
")",
"{",
"ed",
".",
"writeUint32",
"(",
"uint32",
"(",
"item",
")",
")",
"}",
"\n",
"case",
"8",
":",
"inType",
"=",
"inTypeHexInt64",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uintptr",
")",
"{",
"ed",
".",
"writeUint64",
"(",
"uint64",
"(",
"item",
")",
")",
"}",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inType",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"writeItem",
"(",
"ed",
",",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // UintptrField adds a single uintptr field to the event. | [
"UintptrField",
"adds",
"a",
"single",
"uintptr",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L290-L308 |
150,666 | Microsoft/go-winio | pkg/etw/fieldopt.go | UintptrArray | func UintptrArray(name string, values []uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | go | func UintptrArray(name string, values []uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | [
"func",
"UintptrArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uintptr",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"uintptr",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"values",
"[",
"0",
"]",
")",
"{",
"case",
"4",
":",
"inType",
"=",
"inTypeHexInt32",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uintptr",
")",
"{",
"ed",
".",
"writeUint32",
"(",
"uint32",
"(",
"item",
")",
")",
"}",
"\n",
"case",
"8",
":",
"inType",
"=",
"inTypeHexInt64",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uintptr",
")",
"{",
"ed",
".",
"writeUint64",
"(",
"uint64",
"(",
"item",
")",
")",
"}",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inType",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"writeItem",
"(",
"ed",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // UintptrArray adds an array of uintptr to the event. | [
"UintptrArray",
"adds",
"an",
"array",
"of",
"uintptr",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L311-L332 |
150,667 | Microsoft/go-winio | pkg/etw/fieldopt.go | Float32Field | func Float32Field(name string, value float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint32(math.Float32bits(value))
}
} | go | func Float32Field(name string, value float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint32(math.Float32bits(value))
}
} | [
"func",
"Float32Field",
"(",
"name",
"string",
",",
"value",
"float32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeFloat",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint32",
"(",
"math",
".",
"Float32bits",
"(",
"value",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Float32Field adds a single float32 field to the event. | [
"Float32Field",
"adds",
"a",
"single",
"float32",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L335-L340 |
150,668 | Microsoft/go-winio | pkg/etw/fieldopt.go | Float32Array | func Float32Array(name string, values []float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(math.Float32bits(v))
}
}
} | go | func Float32Array(name string, values []float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(math.Float32bits(v))
}
}
} | [
"func",
"Float32Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"float32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeFloat",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint32",
"(",
"math",
".",
"Float32bits",
"(",
"v",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Float32Array adds an array of float32 to the event. | [
"Float32Array",
"adds",
"an",
"array",
"of",
"float32",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L343-L351 |
150,669 | Microsoft/go-winio | pkg/etw/fieldopt.go | Float64Field | func Float64Field(name string, value float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint64(math.Float64bits(value))
}
} | go | func Float64Field(name string, value float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint64(math.Float64bits(value))
}
} | [
"func",
"Float64Field",
"(",
"name",
"string",
",",
"value",
"float64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeDouble",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint64",
"(",
"math",
".",
"Float64bits",
"(",
"value",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Float64Field adds a single float64 field to the event. | [
"Float64Field",
"adds",
"a",
"single",
"float64",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L354-L359 |
150,670 | Microsoft/go-winio | pkg/etw/fieldopt.go | Float64Array | func Float64Array(name string, values []float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(math.Float64bits(v))
}
}
} | go | func Float64Array(name string, values []float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(math.Float64bits(v))
}
}
} | [
"func",
"Float64Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"float64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeDouble",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint64",
"(",
"math",
".",
"Float64bits",
"(",
"v",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Float64Array adds an array of float64 to the event. | [
"Float64Array",
"adds",
"an",
"array",
"of",
"float64",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L362-L370 |
150,671 | Microsoft/go-winio | pkg/etw/fieldopt.go | Struct | func Struct(name string, opts ...FieldOpt) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeStruct(name, uint8(len(opts)), 0)
for _, opt := range opts {
opt(em, ed)
}
}
} | go | func Struct(name string, opts ...FieldOpt) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeStruct(name, uint8(len(opts)), 0)
for _, opt := range opts {
opt(em, ed)
}
}
} | [
"func",
"Struct",
"(",
"name",
"string",
",",
"opts",
"...",
"FieldOpt",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeStruct",
"(",
"name",
",",
"uint8",
"(",
"len",
"(",
"opts",
")",
")",
",",
"0",
")",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"em",
",",
"ed",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Struct adds a nested struct to the event, the FieldOpts in the opts argument
// are used to specify the fields of the struct. | [
"Struct",
"adds",
"a",
"nested",
"struct",
"to",
"the",
"event",
"the",
"FieldOpts",
"in",
"the",
"opts",
"argument",
"are",
"used",
"to",
"specify",
"the",
"fields",
"of",
"the",
"struct",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L374-L381 |
150,672 | Microsoft/go-winio | backuptar/tar.go | BasicInfoHeader | func BasicInfoHeader(name string, size int64, fileInfo *winio.FileBasicInfo) *tar.Header {
hdr := &tar.Header{
Name: filepath.ToSlash(name),
Size: size,
Typeflag: tar.TypeReg,
ModTime: time.Unix(0, fileInfo.LastWriteTime.Nanoseconds()),
ChangeTime: time.Unix(0, fileInfo.ChangeTime.Nanoseconds()),
AccessTime: time.Unix(0, fileInfo.LastAccessTime.Nanoseconds()),
CreationTime: time.Unix(0, fileInfo.CreationTime.Nanoseconds()),
Winheaders: make(map[string]string),
}
hdr.Winheaders[hdrFileAttributes] = fmt.Sprintf("%d", fileInfo.FileAttributes)
if (fileInfo.FileAttributes & syscall.FILE_ATTRIBUTE_DIRECTORY) != 0 {
hdr.Mode |= c_ISDIR
hdr.Size = 0
hdr.Typeflag = tar.TypeDir
}
return hdr
} | go | func BasicInfoHeader(name string, size int64, fileInfo *winio.FileBasicInfo) *tar.Header {
hdr := &tar.Header{
Name: filepath.ToSlash(name),
Size: size,
Typeflag: tar.TypeReg,
ModTime: time.Unix(0, fileInfo.LastWriteTime.Nanoseconds()),
ChangeTime: time.Unix(0, fileInfo.ChangeTime.Nanoseconds()),
AccessTime: time.Unix(0, fileInfo.LastAccessTime.Nanoseconds()),
CreationTime: time.Unix(0, fileInfo.CreationTime.Nanoseconds()),
Winheaders: make(map[string]string),
}
hdr.Winheaders[hdrFileAttributes] = fmt.Sprintf("%d", fileInfo.FileAttributes)
if (fileInfo.FileAttributes & syscall.FILE_ATTRIBUTE_DIRECTORY) != 0 {
hdr.Mode |= c_ISDIR
hdr.Size = 0
hdr.Typeflag = tar.TypeDir
}
return hdr
} | [
"func",
"BasicInfoHeader",
"(",
"name",
"string",
",",
"size",
"int64",
",",
"fileInfo",
"*",
"winio",
".",
"FileBasicInfo",
")",
"*",
"tar",
".",
"Header",
"{",
"hdr",
":=",
"&",
"tar",
".",
"Header",
"{",
"Name",
":",
"filepath",
".",
"ToSlash",
"(",
"name",
")",
",",
"Size",
":",
"size",
",",
"Typeflag",
":",
"tar",
".",
"TypeReg",
",",
"ModTime",
":",
"time",
".",
"Unix",
"(",
"0",
",",
"fileInfo",
".",
"LastWriteTime",
".",
"Nanoseconds",
"(",
")",
")",
",",
"ChangeTime",
":",
"time",
".",
"Unix",
"(",
"0",
",",
"fileInfo",
".",
"ChangeTime",
".",
"Nanoseconds",
"(",
")",
")",
",",
"AccessTime",
":",
"time",
".",
"Unix",
"(",
"0",
",",
"fileInfo",
".",
"LastAccessTime",
".",
"Nanoseconds",
"(",
")",
")",
",",
"CreationTime",
":",
"time",
".",
"Unix",
"(",
"0",
",",
"fileInfo",
".",
"CreationTime",
".",
"Nanoseconds",
"(",
")",
")",
",",
"Winheaders",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
",",
"}",
"\n",
"hdr",
".",
"Winheaders",
"[",
"hdrFileAttributes",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"fileInfo",
".",
"FileAttributes",
")",
"\n\n",
"if",
"(",
"fileInfo",
".",
"FileAttributes",
"&",
"syscall",
".",
"FILE_ATTRIBUTE_DIRECTORY",
")",
"!=",
"0",
"{",
"hdr",
".",
"Mode",
"|=",
"c_ISDIR",
"\n",
"hdr",
".",
"Size",
"=",
"0",
"\n",
"hdr",
".",
"Typeflag",
"=",
"tar",
".",
"TypeDir",
"\n",
"}",
"\n",
"return",
"hdr",
"\n",
"}"
] | // BasicInfoHeader creates a tar header from basic file information. | [
"BasicInfoHeader",
"creates",
"a",
"tar",
"header",
"from",
"basic",
"file",
"information",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backuptar/tar.go#L87-L106 |
150,673 | Microsoft/go-winio | pipe.go | CloseWrite | func (f *win32MessageBytePipe) CloseWrite() error {
if f.writeClosed {
return errPipeWriteClosed
}
err := f.win32File.Flush()
if err != nil {
return err
}
_, err = f.win32File.Write(nil)
if err != nil {
return err
}
f.writeClosed = true
return nil
} | go | func (f *win32MessageBytePipe) CloseWrite() error {
if f.writeClosed {
return errPipeWriteClosed
}
err := f.win32File.Flush()
if err != nil {
return err
}
_, err = f.win32File.Write(nil)
if err != nil {
return err
}
f.writeClosed = true
return nil
} | [
"func",
"(",
"f",
"*",
"win32MessageBytePipe",
")",
"CloseWrite",
"(",
")",
"error",
"{",
"if",
"f",
".",
"writeClosed",
"{",
"return",
"errPipeWriteClosed",
"\n",
"}",
"\n",
"err",
":=",
"f",
".",
"win32File",
".",
"Flush",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"f",
".",
"win32File",
".",
"Write",
"(",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"f",
".",
"writeClosed",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] | // CloseWrite closes the write side of a message pipe in byte mode. | [
"CloseWrite",
"closes",
"the",
"write",
"side",
"of",
"a",
"message",
"pipe",
"in",
"byte",
"mode",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pipe.go#L125-L139 |
150,674 | Microsoft/go-winio | pipe.go | Read | func (f *win32MessageBytePipe) Read(b []byte) (int, error) {
if f.readEOF {
return 0, io.EOF
}
n, err := f.win32File.Read(b)
if err == io.EOF {
// If this was the result of a zero-byte read, then
// it is possible that the read was due to a zero-size
// message. Since we are simulating CloseWrite with a
// zero-byte message, ensure that all future Read() calls
// also return EOF.
f.readEOF = true
} else if err == syscall.ERROR_MORE_DATA {
// ERROR_MORE_DATA indicates that the pipe's read mode is message mode
// and the message still has more bytes. Treat this as a success, since
// this package presents all named pipes as byte streams.
err = nil
}
return n, err
} | go | func (f *win32MessageBytePipe) Read(b []byte) (int, error) {
if f.readEOF {
return 0, io.EOF
}
n, err := f.win32File.Read(b)
if err == io.EOF {
// If this was the result of a zero-byte read, then
// it is possible that the read was due to a zero-size
// message. Since we are simulating CloseWrite with a
// zero-byte message, ensure that all future Read() calls
// also return EOF.
f.readEOF = true
} else if err == syscall.ERROR_MORE_DATA {
// ERROR_MORE_DATA indicates that the pipe's read mode is message mode
// and the message still has more bytes. Treat this as a success, since
// this package presents all named pipes as byte streams.
err = nil
}
return n, err
} | [
"func",
"(",
"f",
"*",
"win32MessageBytePipe",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"f",
".",
"readEOF",
"{",
"return",
"0",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"n",
",",
"err",
":=",
"f",
".",
"win32File",
".",
"Read",
"(",
"b",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"// If this was the result of a zero-byte read, then",
"// it is possible that the read was due to a zero-size",
"// message. Since we are simulating CloseWrite with a",
"// zero-byte message, ensure that all future Read() calls",
"// also return EOF.",
"f",
".",
"readEOF",
"=",
"true",
"\n",
"}",
"else",
"if",
"err",
"==",
"syscall",
".",
"ERROR_MORE_DATA",
"{",
"// ERROR_MORE_DATA indicates that the pipe's read mode is message mode",
"// and the message still has more bytes. Treat this as a success, since",
"// this package presents all named pipes as byte streams.",
"err",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] | // Read reads bytes from a message pipe in byte mode. A read of a zero-byte message on a message
// mode pipe will return io.EOF, as will all subsequent reads. | [
"Read",
"reads",
"bytes",
"from",
"a",
"message",
"pipe",
"in",
"byte",
"mode",
".",
"A",
"read",
"of",
"a",
"zero",
"-",
"byte",
"message",
"on",
"a",
"message",
"mode",
"pipe",
"will",
"return",
"io",
".",
"EOF",
"as",
"will",
"all",
"subsequent",
"reads",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pipe.go#L155-L174 |
150,675 | Microsoft/go-winio | pipe.go | tryDialPipe | func tryDialPipe(ctx context.Context, path *string) (syscall.Handle, error) {
for {
select {
case <-ctx.Done():
return syscall.Handle(0), ctx.Err()
default:
h, err := createFile(*path, syscall.GENERIC_READ|syscall.GENERIC_WRITE, 0, nil, syscall.OPEN_EXISTING, syscall.FILE_FLAG_OVERLAPPED|cSECURITY_SQOS_PRESENT|cSECURITY_ANONYMOUS, 0)
if err == nil {
return h, nil
}
if err != cERROR_PIPE_BUSY {
return h, &os.PathError{Err: err, Op: "open", Path: *path}
}
// Wait 10 msec and try again. This is a rather simplistic
// view, as we always try each 10 milliseconds.
time.Sleep(time.Millisecond * 10)
}
}
} | go | func tryDialPipe(ctx context.Context, path *string) (syscall.Handle, error) {
for {
select {
case <-ctx.Done():
return syscall.Handle(0), ctx.Err()
default:
h, err := createFile(*path, syscall.GENERIC_READ|syscall.GENERIC_WRITE, 0, nil, syscall.OPEN_EXISTING, syscall.FILE_FLAG_OVERLAPPED|cSECURITY_SQOS_PRESENT|cSECURITY_ANONYMOUS, 0)
if err == nil {
return h, nil
}
if err != cERROR_PIPE_BUSY {
return h, &os.PathError{Err: err, Op: "open", Path: *path}
}
// Wait 10 msec and try again. This is a rather simplistic
// view, as we always try each 10 milliseconds.
time.Sleep(time.Millisecond * 10)
}
}
} | [
"func",
"tryDialPipe",
"(",
"ctx",
"context",
".",
"Context",
",",
"path",
"*",
"string",
")",
"(",
"syscall",
".",
"Handle",
",",
"error",
")",
"{",
"for",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"syscall",
".",
"Handle",
"(",
"0",
")",
",",
"ctx",
".",
"Err",
"(",
")",
"\n",
"default",
":",
"h",
",",
"err",
":=",
"createFile",
"(",
"*",
"path",
",",
"syscall",
".",
"GENERIC_READ",
"|",
"syscall",
".",
"GENERIC_WRITE",
",",
"0",
",",
"nil",
",",
"syscall",
".",
"OPEN_EXISTING",
",",
"syscall",
".",
"FILE_FLAG_OVERLAPPED",
"|",
"cSECURITY_SQOS_PRESENT",
"|",
"cSECURITY_ANONYMOUS",
",",
"0",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"h",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"cERROR_PIPE_BUSY",
"{",
"return",
"h",
",",
"&",
"os",
".",
"PathError",
"{",
"Err",
":",
"err",
",",
"Op",
":",
"\"",
"\"",
",",
"Path",
":",
"*",
"path",
"}",
"\n",
"}",
"\n",
"// Wait 10 msec and try again. This is a rather simplistic",
"// view, as we always try each 10 milliseconds.",
"time",
".",
"Sleep",
"(",
"time",
".",
"Millisecond",
"*",
"10",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // tryDialPipe attempts to dial the pipe at `path` until `ctx` cancellation or timeout. | [
"tryDialPipe",
"attempts",
"to",
"dial",
"the",
"pipe",
"at",
"path",
"until",
"ctx",
"cancellation",
"or",
"timeout",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pipe.go#L185-L203 |
150,676 | Microsoft/go-winio | pipe.go | DialPipeContext | func DialPipeContext(ctx context.Context, path string) (net.Conn, error) {
var err error
var h syscall.Handle
h, err = tryDialPipe(ctx, &path)
if err != nil {
return nil, err
}
var flags uint32
err = getNamedPipeInfo(h, &flags, nil, nil, nil)
if err != nil {
return nil, err
}
f, err := makeWin32File(h)
if err != nil {
syscall.Close(h)
return nil, err
}
// If the pipe is in message mode, return a message byte pipe, which
// supports CloseWrite().
if flags&cPIPE_TYPE_MESSAGE != 0 {
return &win32MessageBytePipe{
win32Pipe: win32Pipe{win32File: f, path: path},
}, nil
}
return &win32Pipe{win32File: f, path: path}, nil
} | go | func DialPipeContext(ctx context.Context, path string) (net.Conn, error) {
var err error
var h syscall.Handle
h, err = tryDialPipe(ctx, &path)
if err != nil {
return nil, err
}
var flags uint32
err = getNamedPipeInfo(h, &flags, nil, nil, nil)
if err != nil {
return nil, err
}
f, err := makeWin32File(h)
if err != nil {
syscall.Close(h)
return nil, err
}
// If the pipe is in message mode, return a message byte pipe, which
// supports CloseWrite().
if flags&cPIPE_TYPE_MESSAGE != 0 {
return &win32MessageBytePipe{
win32Pipe: win32Pipe{win32File: f, path: path},
}, nil
}
return &win32Pipe{win32File: f, path: path}, nil
} | [
"func",
"DialPipeContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"path",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"h",
"syscall",
".",
"Handle",
"\n",
"h",
",",
"err",
"=",
"tryDialPipe",
"(",
"ctx",
",",
"&",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"flags",
"uint32",
"\n",
"err",
"=",
"getNamedPipeInfo",
"(",
"h",
",",
"&",
"flags",
",",
"nil",
",",
"nil",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"f",
",",
"err",
":=",
"makeWin32File",
"(",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"syscall",
".",
"Close",
"(",
"h",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// If the pipe is in message mode, return a message byte pipe, which",
"// supports CloseWrite().",
"if",
"flags",
"&",
"cPIPE_TYPE_MESSAGE",
"!=",
"0",
"{",
"return",
"&",
"win32MessageBytePipe",
"{",
"win32Pipe",
":",
"win32Pipe",
"{",
"win32File",
":",
"f",
",",
"path",
":",
"path",
"}",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"win32Pipe",
"{",
"win32File",
":",
"f",
",",
"path",
":",
"path",
"}",
",",
"nil",
"\n",
"}"
] | // DialPipeContext attempts to connect to a named pipe by `path` until `ctx`
// cancellation or timeout. | [
"DialPipeContext",
"attempts",
"to",
"connect",
"to",
"a",
"named",
"pipe",
"by",
"path",
"until",
"ctx",
"cancellation",
"or",
"timeout",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pipe.go#L225-L253 |
150,677 | Microsoft/go-winio | backup.go | Read | func (r *BackupStreamReader) Read(b []byte) (int, error) {
if r.bytesLeft == 0 {
return 0, io.EOF
}
if int64(len(b)) > r.bytesLeft {
b = b[:r.bytesLeft]
}
n, err := r.r.Read(b)
r.bytesLeft -= int64(n)
if err == io.EOF {
err = io.ErrUnexpectedEOF
} else if r.bytesLeft == 0 && err == nil {
err = io.EOF
}
return n, err
} | go | func (r *BackupStreamReader) Read(b []byte) (int, error) {
if r.bytesLeft == 0 {
return 0, io.EOF
}
if int64(len(b)) > r.bytesLeft {
b = b[:r.bytesLeft]
}
n, err := r.r.Read(b)
r.bytesLeft -= int64(n)
if err == io.EOF {
err = io.ErrUnexpectedEOF
} else if r.bytesLeft == 0 && err == nil {
err = io.EOF
}
return n, err
} | [
"func",
"(",
"r",
"*",
"BackupStreamReader",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"r",
".",
"bytesLeft",
"==",
"0",
"{",
"return",
"0",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"if",
"int64",
"(",
"len",
"(",
"b",
")",
")",
">",
"r",
".",
"bytesLeft",
"{",
"b",
"=",
"b",
"[",
":",
"r",
".",
"bytesLeft",
"]",
"\n",
"}",
"\n",
"n",
",",
"err",
":=",
"r",
".",
"r",
".",
"Read",
"(",
"b",
")",
"\n",
"r",
".",
"bytesLeft",
"-=",
"int64",
"(",
"n",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"err",
"=",
"io",
".",
"ErrUnexpectedEOF",
"\n",
"}",
"else",
"if",
"r",
".",
"bytesLeft",
"==",
"0",
"&&",
"err",
"==",
"nil",
"{",
"err",
"=",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] | // Read reads from the current backup stream. | [
"Read",
"reads",
"from",
"the",
"current",
"backup",
"stream",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L116-L131 |
150,678 | Microsoft/go-winio | backup.go | Write | func (w *BackupStreamWriter) Write(b []byte) (int, error) {
if w.bytesLeft < int64(len(b)) {
return 0, fmt.Errorf("too many bytes by %d", int64(len(b))-w.bytesLeft)
}
n, err := w.w.Write(b)
w.bytesLeft -= int64(n)
return n, err
} | go | func (w *BackupStreamWriter) Write(b []byte) (int, error) {
if w.bytesLeft < int64(len(b)) {
return 0, fmt.Errorf("too many bytes by %d", int64(len(b))-w.bytesLeft)
}
n, err := w.w.Write(b)
w.bytesLeft -= int64(n)
return n, err
} | [
"func",
"(",
"w",
"*",
"BackupStreamWriter",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"w",
".",
"bytesLeft",
"<",
"int64",
"(",
"len",
"(",
"b",
")",
")",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"int64",
"(",
"len",
"(",
"b",
")",
")",
"-",
"w",
".",
"bytesLeft",
")",
"\n",
"}",
"\n",
"n",
",",
"err",
":=",
"w",
".",
"w",
".",
"Write",
"(",
"b",
")",
"\n",
"w",
".",
"bytesLeft",
"-=",
"int64",
"(",
"n",
")",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] | // Write writes to the current backup stream. | [
"Write",
"writes",
"to",
"the",
"current",
"backup",
"stream",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L178-L185 |
150,679 | Microsoft/go-winio | backup.go | NewBackupFileReader | func NewBackupFileReader(f *os.File, includeSecurity bool) *BackupFileReader {
r := &BackupFileReader{f, includeSecurity, 0}
return r
} | go | func NewBackupFileReader(f *os.File, includeSecurity bool) *BackupFileReader {
r := &BackupFileReader{f, includeSecurity, 0}
return r
} | [
"func",
"NewBackupFileReader",
"(",
"f",
"*",
"os",
".",
"File",
",",
"includeSecurity",
"bool",
")",
"*",
"BackupFileReader",
"{",
"r",
":=",
"&",
"BackupFileReader",
"{",
"f",
",",
"includeSecurity",
",",
"0",
"}",
"\n",
"return",
"r",
"\n",
"}"
] | // NewBackupFileReader returns a new BackupFileReader from a file handle. If includeSecurity is true,
// Read will attempt to read the security descriptor of the file. | [
"NewBackupFileReader",
"returns",
"a",
"new",
"BackupFileReader",
"from",
"a",
"file",
"handle",
".",
"If",
"includeSecurity",
"is",
"true",
"Read",
"will",
"attempt",
"to",
"read",
"the",
"security",
"descriptor",
"of",
"the",
"file",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L196-L199 |
150,680 | Microsoft/go-winio | backup.go | Close | func (r *BackupFileReader) Close() error {
if r.ctx != 0 {
backupRead(syscall.Handle(r.f.Fd()), nil, nil, true, false, &r.ctx)
runtime.KeepAlive(r.f)
r.ctx = 0
}
return nil
} | go | func (r *BackupFileReader) Close() error {
if r.ctx != 0 {
backupRead(syscall.Handle(r.f.Fd()), nil, nil, true, false, &r.ctx)
runtime.KeepAlive(r.f)
r.ctx = 0
}
return nil
} | [
"func",
"(",
"r",
"*",
"BackupFileReader",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"r",
".",
"ctx",
"!=",
"0",
"{",
"backupRead",
"(",
"syscall",
".",
"Handle",
"(",
"r",
".",
"f",
".",
"Fd",
"(",
")",
")",
",",
"nil",
",",
"nil",
",",
"true",
",",
"false",
",",
"&",
"r",
".",
"ctx",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"r",
".",
"f",
")",
"\n",
"r",
".",
"ctx",
"=",
"0",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close frees Win32 resources associated with the BackupFileReader. It does not close
// the underlying file. | [
"Close",
"frees",
"Win32",
"resources",
"associated",
"with",
"the",
"BackupFileReader",
".",
"It",
"does",
"not",
"close",
"the",
"underlying",
"file",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L217-L224 |
150,681 | Microsoft/go-winio | backup.go | Write | func (w *BackupFileWriter) Write(b []byte) (int, error) {
var bytesWritten uint32
err := backupWrite(syscall.Handle(w.f.Fd()), b, &bytesWritten, false, w.includeSecurity, &w.ctx)
if err != nil {
return 0, &os.PathError{"BackupWrite", w.f.Name(), err}
}
runtime.KeepAlive(w.f)
if int(bytesWritten) != len(b) {
return int(bytesWritten), errors.New("not all bytes could be written")
}
return len(b), nil
} | go | func (w *BackupFileWriter) Write(b []byte) (int, error) {
var bytesWritten uint32
err := backupWrite(syscall.Handle(w.f.Fd()), b, &bytesWritten, false, w.includeSecurity, &w.ctx)
if err != nil {
return 0, &os.PathError{"BackupWrite", w.f.Name(), err}
}
runtime.KeepAlive(w.f)
if int(bytesWritten) != len(b) {
return int(bytesWritten), errors.New("not all bytes could be written")
}
return len(b), nil
} | [
"func",
"(",
"w",
"*",
"BackupFileWriter",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"bytesWritten",
"uint32",
"\n",
"err",
":=",
"backupWrite",
"(",
"syscall",
".",
"Handle",
"(",
"w",
".",
"f",
".",
"Fd",
"(",
")",
")",
",",
"b",
",",
"&",
"bytesWritten",
",",
"false",
",",
"w",
".",
"includeSecurity",
",",
"&",
"w",
".",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"w",
".",
"f",
".",
"Name",
"(",
")",
",",
"err",
"}",
"\n",
"}",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"w",
".",
"f",
")",
"\n",
"if",
"int",
"(",
"bytesWritten",
")",
"!=",
"len",
"(",
"b",
")",
"{",
"return",
"int",
"(",
"bytesWritten",
")",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"len",
"(",
"b",
")",
",",
"nil",
"\n",
"}"
] | // Write restores a portion of the file using the provided backup stream. | [
"Write",
"restores",
"a",
"portion",
"of",
"the",
"file",
"using",
"the",
"provided",
"backup",
"stream",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L241-L252 |
150,682 | Microsoft/go-winio | backup.go | Close | func (w *BackupFileWriter) Close() error {
if w.ctx != 0 {
backupWrite(syscall.Handle(w.f.Fd()), nil, nil, true, false, &w.ctx)
runtime.KeepAlive(w.f)
w.ctx = 0
}
return nil
} | go | func (w *BackupFileWriter) Close() error {
if w.ctx != 0 {
backupWrite(syscall.Handle(w.f.Fd()), nil, nil, true, false, &w.ctx)
runtime.KeepAlive(w.f)
w.ctx = 0
}
return nil
} | [
"func",
"(",
"w",
"*",
"BackupFileWriter",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"w",
".",
"ctx",
"!=",
"0",
"{",
"backupWrite",
"(",
"syscall",
".",
"Handle",
"(",
"w",
".",
"f",
".",
"Fd",
"(",
")",
")",
",",
"nil",
",",
"nil",
",",
"true",
",",
"false",
",",
"&",
"w",
".",
"ctx",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"w",
".",
"f",
")",
"\n",
"w",
".",
"ctx",
"=",
"0",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close frees Win32 resources associated with the BackupFileWriter. It does not
// close the underlying file. | [
"Close",
"frees",
"Win32",
"resources",
"associated",
"with",
"the",
"BackupFileWriter",
".",
"It",
"does",
"not",
"close",
"the",
"underlying",
"file",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L256-L263 |
150,683 | Microsoft/go-winio | vhd/vhd.go | CreateVhdx | func CreateVhdx(path string, maxSizeInGb, blockSizeInMb uint32) error {
var (
defaultType virtualStorageType
handle syscall.Handle
)
parameters := createVirtualDiskParameters{
Version: 2,
Version2: createVersion2{
MaximumSize: uint64(maxSizeInGb) * 1024 * 1024 * 1024,
BlockSizeInBytes: blockSizeInMb * 1024 * 1024,
},
}
if err := createVirtualDisk(
&defaultType,
path,
uint32(VirtualDiskAccessNone),
nil,
uint32(createVirtualDiskFlagNone),
0,
¶meters,
nil,
&handle); err != nil {
return err
}
if err := syscall.CloseHandle(handle); err != nil {
return err
}
return nil
} | go | func CreateVhdx(path string, maxSizeInGb, blockSizeInMb uint32) error {
var (
defaultType virtualStorageType
handle syscall.Handle
)
parameters := createVirtualDiskParameters{
Version: 2,
Version2: createVersion2{
MaximumSize: uint64(maxSizeInGb) * 1024 * 1024 * 1024,
BlockSizeInBytes: blockSizeInMb * 1024 * 1024,
},
}
if err := createVirtualDisk(
&defaultType,
path,
uint32(VirtualDiskAccessNone),
nil,
uint32(createVirtualDiskFlagNone),
0,
¶meters,
nil,
&handle); err != nil {
return err
}
if err := syscall.CloseHandle(handle); err != nil {
return err
}
return nil
} | [
"func",
"CreateVhdx",
"(",
"path",
"string",
",",
"maxSizeInGb",
",",
"blockSizeInMb",
"uint32",
")",
"error",
"{",
"var",
"(",
"defaultType",
"virtualStorageType",
"\n",
"handle",
"syscall",
".",
"Handle",
"\n",
")",
"\n\n",
"parameters",
":=",
"createVirtualDiskParameters",
"{",
"Version",
":",
"2",
",",
"Version2",
":",
"createVersion2",
"{",
"MaximumSize",
":",
"uint64",
"(",
"maxSizeInGb",
")",
"*",
"1024",
"*",
"1024",
"*",
"1024",
",",
"BlockSizeInBytes",
":",
"blockSizeInMb",
"*",
"1024",
"*",
"1024",
",",
"}",
",",
"}",
"\n\n",
"if",
"err",
":=",
"createVirtualDisk",
"(",
"&",
"defaultType",
",",
"path",
",",
"uint32",
"(",
"VirtualDiskAccessNone",
")",
",",
"nil",
",",
"uint32",
"(",
"createVirtualDiskFlagNone",
")",
",",
"0",
",",
"&",
"parameters",
",",
"nil",
",",
"&",
"handle",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"syscall",
".",
"CloseHandle",
"(",
"handle",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CreateVhdx will create a simple vhdx file at the given path using default values. | [
"CreateVhdx",
"will",
"create",
"a",
"simple",
"vhdx",
"file",
"at",
"the",
"given",
"path",
"using",
"default",
"values",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/vhd/vhd.go#L86-L118 |
150,684 | Microsoft/go-winio | vhd/vhd.go | DetachVhd | func DetachVhd(path string) error {
handle, err := OpenVirtualDisk(path, VirtualDiskAccessDetach, OpenVirtualDiskFlagNone)
if err != nil {
return err
}
defer syscall.CloseHandle(handle)
return detachVirtualDisk(handle, 0, 0)
} | go | func DetachVhd(path string) error {
handle, err := OpenVirtualDisk(path, VirtualDiskAccessDetach, OpenVirtualDiskFlagNone)
if err != nil {
return err
}
defer syscall.CloseHandle(handle)
return detachVirtualDisk(handle, 0, 0)
} | [
"func",
"DetachVhd",
"(",
"path",
"string",
")",
"error",
"{",
"handle",
",",
"err",
":=",
"OpenVirtualDisk",
"(",
"path",
",",
"VirtualDiskAccessDetach",
",",
"OpenVirtualDiskFlagNone",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"syscall",
".",
"CloseHandle",
"(",
"handle",
")",
"\n",
"return",
"detachVirtualDisk",
"(",
"handle",
",",
"0",
",",
"0",
")",
"\n",
"}"
] | // DetachVhd detaches a VHD attached at the given path. | [
"DetachVhd",
"detaches",
"a",
"VHD",
"attached",
"at",
"the",
"given",
"path",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/vhd/vhd.go#L121-L128 |
150,685 | Microsoft/go-winio | vhd/vhd.go | OpenVirtualDisk | func OpenVirtualDisk(path string, accessMask VirtualDiskAccessMask, flag VirtualDiskFlag) (syscall.Handle, error) {
var (
defaultType virtualStorageType
handle syscall.Handle
)
parameters := openVirtualDiskParameters{Version: 2}
if err := openVirtualDisk(
&defaultType,
path,
uint32(accessMask),
uint32(flag),
¶meters,
&handle); err != nil {
return 0, err
}
return handle, nil
} | go | func OpenVirtualDisk(path string, accessMask VirtualDiskAccessMask, flag VirtualDiskFlag) (syscall.Handle, error) {
var (
defaultType virtualStorageType
handle syscall.Handle
)
parameters := openVirtualDiskParameters{Version: 2}
if err := openVirtualDisk(
&defaultType,
path,
uint32(accessMask),
uint32(flag),
¶meters,
&handle); err != nil {
return 0, err
}
return handle, nil
} | [
"func",
"OpenVirtualDisk",
"(",
"path",
"string",
",",
"accessMask",
"VirtualDiskAccessMask",
",",
"flag",
"VirtualDiskFlag",
")",
"(",
"syscall",
".",
"Handle",
",",
"error",
")",
"{",
"var",
"(",
"defaultType",
"virtualStorageType",
"\n",
"handle",
"syscall",
".",
"Handle",
"\n",
")",
"\n",
"parameters",
":=",
"openVirtualDiskParameters",
"{",
"Version",
":",
"2",
"}",
"\n",
"if",
"err",
":=",
"openVirtualDisk",
"(",
"&",
"defaultType",
",",
"path",
",",
"uint32",
"(",
"accessMask",
")",
",",
"uint32",
"(",
"flag",
")",
",",
"&",
"parameters",
",",
"&",
"handle",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"handle",
",",
"nil",
"\n",
"}"
] | // OpenVirtuaDisk obtains a handle to a VHD opened with supplied access mask and flags. | [
"OpenVirtuaDisk",
"obtains",
"a",
"handle",
"to",
"a",
"VHD",
"opened",
"with",
"supplied",
"access",
"mask",
"and",
"flags",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/vhd/vhd.go#L131-L147 |
150,686 | Microsoft/go-winio | pkg/etwlogrus/hook.go | NewHook | func NewHook(providerName string) (*Hook, error) {
provider, err := etw.NewProvider(providerName, nil)
if err != nil {
return nil, err
}
return &Hook{provider, true}, nil
} | go | func NewHook(providerName string) (*Hook, error) {
provider, err := etw.NewProvider(providerName, nil)
if err != nil {
return nil, err
}
return &Hook{provider, true}, nil
} | [
"func",
"NewHook",
"(",
"providerName",
"string",
")",
"(",
"*",
"Hook",
",",
"error",
")",
"{",
"provider",
",",
"err",
":=",
"etw",
".",
"NewProvider",
"(",
"providerName",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"Hook",
"{",
"provider",
",",
"true",
"}",
",",
"nil",
"\n",
"}"
] | // NewHook registers a new ETW provider and returns a hook to log from it. The
// provider will be closed when the hook is closed. | [
"NewHook",
"registers",
"a",
"new",
"ETW",
"provider",
"and",
"returns",
"a",
"hook",
"to",
"log",
"from",
"it",
".",
"The",
"provider",
"will",
"be",
"closed",
"when",
"the",
"hook",
"is",
"closed",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etwlogrus/hook.go#L16-L23 |
150,687 | Microsoft/go-winio | pkg/etwlogrus/hook.go | NewHookFromProvider | func NewHookFromProvider(provider *etw.Provider) (*Hook, error) {
return &Hook{provider, false}, nil
} | go | func NewHookFromProvider(provider *etw.Provider) (*Hook, error) {
return &Hook{provider, false}, nil
} | [
"func",
"NewHookFromProvider",
"(",
"provider",
"*",
"etw",
".",
"Provider",
")",
"(",
"*",
"Hook",
",",
"error",
")",
"{",
"return",
"&",
"Hook",
"{",
"provider",
",",
"false",
"}",
",",
"nil",
"\n",
"}"
] | // NewHookFromProvider creates a new hook based on an existing ETW provider. The
// provider will not be closed when the hook is closed. | [
"NewHookFromProvider",
"creates",
"a",
"new",
"hook",
"based",
"on",
"an",
"existing",
"ETW",
"provider",
".",
"The",
"provider",
"will",
"not",
"be",
"closed",
"when",
"the",
"hook",
"is",
"closed",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etwlogrus/hook.go#L27-L29 |
150,688 | Microsoft/go-winio | pkg/etwlogrus/hook.go | Levels | func (h *Hook) Levels() []logrus.Level {
return []logrus.Level{
logrus.TraceLevel,
logrus.DebugLevel,
logrus.InfoLevel,
logrus.WarnLevel,
logrus.ErrorLevel,
logrus.FatalLevel,
logrus.PanicLevel,
}
} | go | func (h *Hook) Levels() []logrus.Level {
return []logrus.Level{
logrus.TraceLevel,
logrus.DebugLevel,
logrus.InfoLevel,
logrus.WarnLevel,
logrus.ErrorLevel,
logrus.FatalLevel,
logrus.PanicLevel,
}
} | [
"func",
"(",
"h",
"*",
"Hook",
")",
"Levels",
"(",
")",
"[",
"]",
"logrus",
".",
"Level",
"{",
"return",
"[",
"]",
"logrus",
".",
"Level",
"{",
"logrus",
".",
"TraceLevel",
",",
"logrus",
".",
"DebugLevel",
",",
"logrus",
".",
"InfoLevel",
",",
"logrus",
".",
"WarnLevel",
",",
"logrus",
".",
"ErrorLevel",
",",
"logrus",
".",
"FatalLevel",
",",
"logrus",
".",
"PanicLevel",
",",
"}",
"\n",
"}"
] | // Levels returns the set of levels that this hook wants to receive log entries
// for. | [
"Levels",
"returns",
"the",
"set",
"of",
"levels",
"that",
"this",
"hook",
"wants",
"to",
"receive",
"log",
"entries",
"for",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etwlogrus/hook.go#L33-L43 |
150,689 | Microsoft/go-winio | pkg/etwlogrus/hook.go | Fire | func (h *Hook) Fire(e *logrus.Entry) error {
// Logrus defines more levels than ETW typically uses, but analysis is
// easiest when using a consistent set of levels across ETW providers, so we
// map the Logrus levels to ETW levels.
level := logrusToETWLevelMap[e.Level]
if !h.provider.IsEnabledForLevel(level) {
return nil
}
// Reserve extra space for the message field.
fields := make([]etw.FieldOpt, 0, len(e.Data)+1)
fields = append(fields, etw.StringField("Message", e.Message))
for k, v := range e.Data {
fields = append(fields, etw.SmartField(k, v))
}
return h.provider.WriteEvent(
"LogrusEntry",
etw.WithEventOpts(etw.WithLevel(level)),
fields)
} | go | func (h *Hook) Fire(e *logrus.Entry) error {
// Logrus defines more levels than ETW typically uses, but analysis is
// easiest when using a consistent set of levels across ETW providers, so we
// map the Logrus levels to ETW levels.
level := logrusToETWLevelMap[e.Level]
if !h.provider.IsEnabledForLevel(level) {
return nil
}
// Reserve extra space for the message field.
fields := make([]etw.FieldOpt, 0, len(e.Data)+1)
fields = append(fields, etw.StringField("Message", e.Message))
for k, v := range e.Data {
fields = append(fields, etw.SmartField(k, v))
}
return h.provider.WriteEvent(
"LogrusEntry",
etw.WithEventOpts(etw.WithLevel(level)),
fields)
} | [
"func",
"(",
"h",
"*",
"Hook",
")",
"Fire",
"(",
"e",
"*",
"logrus",
".",
"Entry",
")",
"error",
"{",
"// Logrus defines more levels than ETW typically uses, but analysis is",
"// easiest when using a consistent set of levels across ETW providers, so we",
"// map the Logrus levels to ETW levels.",
"level",
":=",
"logrusToETWLevelMap",
"[",
"e",
".",
"Level",
"]",
"\n",
"if",
"!",
"h",
".",
"provider",
".",
"IsEnabledForLevel",
"(",
"level",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Reserve extra space for the message field.",
"fields",
":=",
"make",
"(",
"[",
"]",
"etw",
".",
"FieldOpt",
",",
"0",
",",
"len",
"(",
"e",
".",
"Data",
")",
"+",
"1",
")",
"\n\n",
"fields",
"=",
"append",
"(",
"fields",
",",
"etw",
".",
"StringField",
"(",
"\"",
"\"",
",",
"e",
".",
"Message",
")",
")",
"\n\n",
"for",
"k",
",",
"v",
":=",
"range",
"e",
".",
"Data",
"{",
"fields",
"=",
"append",
"(",
"fields",
",",
"etw",
".",
"SmartField",
"(",
"k",
",",
"v",
")",
")",
"\n",
"}",
"\n\n",
"return",
"h",
".",
"provider",
".",
"WriteEvent",
"(",
"\"",
"\"",
",",
"etw",
".",
"WithEventOpts",
"(",
"etw",
".",
"WithLevel",
"(",
"level",
")",
")",
",",
"fields",
")",
"\n",
"}"
] | // Fire receives each Logrus entry as it is logged, and logs it to ETW. | [
"Fire",
"receives",
"each",
"Logrus",
"entry",
"as",
"it",
"is",
"logged",
"and",
"logs",
"it",
"to",
"ETW",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etwlogrus/hook.go#L56-L78 |
150,690 | Microsoft/go-winio | pkg/etwlogrus/hook.go | Close | func (h *Hook) Close() error {
if h.closeProvider {
return h.provider.Close()
}
return nil
} | go | func (h *Hook) Close() error {
if h.closeProvider {
return h.provider.Close()
}
return nil
} | [
"func",
"(",
"h",
"*",
"Hook",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"h",
".",
"closeProvider",
"{",
"return",
"h",
".",
"provider",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close cleans up the hook and closes the ETW provider. If the provder was
// registered by etwlogrus, it will be closed as part of `Close`. If the
// provider was passed in, it will not be closed. | [
"Close",
"cleans",
"up",
"the",
"hook",
"and",
"closes",
"the",
"ETW",
"provider",
".",
"If",
"the",
"provder",
"was",
"registered",
"by",
"etwlogrus",
"it",
"will",
"be",
"closed",
"as",
"part",
"of",
"Close",
".",
"If",
"the",
"provider",
"was",
"passed",
"in",
"it",
"will",
"not",
"be",
"closed",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etwlogrus/hook.go#L83-L88 |
150,691 | Microsoft/go-winio | privilege.go | RunWithPrivilege | func RunWithPrivilege(name string, fn func() error) error {
return RunWithPrivileges([]string{name}, fn)
} | go | func RunWithPrivilege(name string, fn func() error) error {
return RunWithPrivileges([]string{name}, fn)
} | [
"func",
"RunWithPrivilege",
"(",
"name",
"string",
",",
"fn",
"func",
"(",
")",
"error",
")",
"error",
"{",
"return",
"RunWithPrivileges",
"(",
"[",
"]",
"string",
"{",
"name",
"}",
",",
"fn",
")",
"\n",
"}"
] | // RunWithPrivilege enables a single privilege for a function call. | [
"RunWithPrivilege",
"enables",
"a",
"single",
"privilege",
"for",
"a",
"function",
"call",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/privilege.go#L71-L73 |
150,692 | Microsoft/go-winio | privilege.go | RunWithPrivileges | func RunWithPrivileges(names []string, fn func() error) error {
privileges, err := mapPrivileges(names)
if err != nil {
return err
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
token, err := newThreadToken()
if err != nil {
return err
}
defer releaseThreadToken(token)
err = adjustPrivileges(token, privileges, SE_PRIVILEGE_ENABLED)
if err != nil {
return err
}
return fn()
} | go | func RunWithPrivileges(names []string, fn func() error) error {
privileges, err := mapPrivileges(names)
if err != nil {
return err
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
token, err := newThreadToken()
if err != nil {
return err
}
defer releaseThreadToken(token)
err = adjustPrivileges(token, privileges, SE_PRIVILEGE_ENABLED)
if err != nil {
return err
}
return fn()
} | [
"func",
"RunWithPrivileges",
"(",
"names",
"[",
"]",
"string",
",",
"fn",
"func",
"(",
")",
"error",
")",
"error",
"{",
"privileges",
",",
"err",
":=",
"mapPrivileges",
"(",
"names",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n",
"token",
",",
"err",
":=",
"newThreadToken",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"releaseThreadToken",
"(",
"token",
")",
"\n",
"err",
"=",
"adjustPrivileges",
"(",
"token",
",",
"privileges",
",",
"SE_PRIVILEGE_ENABLED",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"fn",
"(",
")",
"\n",
"}"
] | // RunWithPrivileges enables privileges for a function call. | [
"RunWithPrivileges",
"enables",
"privileges",
"for",
"a",
"function",
"call",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/privilege.go#L76-L93 |
150,693 | Microsoft/go-winio | wim/wim.go | Time | func (ft *Filetime) Time() time.Time {
// 100-nanosecond intervals since January 1, 1601
nsec := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime)
// change starting time to the Epoch (00:00:00 UTC, January 1, 1970)
nsec -= 116444736000000000
// convert into nanoseconds
nsec *= 100
return time.Unix(0, nsec)
} | go | func (ft *Filetime) Time() time.Time {
// 100-nanosecond intervals since January 1, 1601
nsec := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime)
// change starting time to the Epoch (00:00:00 UTC, January 1, 1970)
nsec -= 116444736000000000
// convert into nanoseconds
nsec *= 100
return time.Unix(0, nsec)
} | [
"func",
"(",
"ft",
"*",
"Filetime",
")",
"Time",
"(",
")",
"time",
".",
"Time",
"{",
"// 100-nanosecond intervals since January 1, 1601",
"nsec",
":=",
"int64",
"(",
"ft",
".",
"HighDateTime",
")",
"<<",
"32",
"+",
"int64",
"(",
"ft",
".",
"LowDateTime",
")",
"\n",
"// change starting time to the Epoch (00:00:00 UTC, January 1, 1970)",
"nsec",
"-=",
"116444736000000000",
"\n",
"// convert into nanoseconds",
"nsec",
"*=",
"100",
"\n",
"return",
"time",
".",
"Unix",
"(",
"0",
",",
"nsec",
")",
"\n",
"}"
] | // Time returns the time as time.Time. | [
"Time",
"returns",
"the",
"time",
"as",
"time",
".",
"Time",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L199-L207 |
150,694 | Microsoft/go-winio | wim/wim.go | UnmarshalXML | func (ft *Filetime) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
type time struct {
Low string `xml:"LOWPART"`
High string `xml:"HIGHPART"`
}
var t time
err := d.DecodeElement(&t, &start)
if err != nil {
return err
}
low, err := strconv.ParseUint(t.Low, 0, 32)
if err != nil {
return err
}
high, err := strconv.ParseUint(t.High, 0, 32)
if err != nil {
return err
}
ft.LowDateTime = uint32(low)
ft.HighDateTime = uint32(high)
return nil
} | go | func (ft *Filetime) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
type time struct {
Low string `xml:"LOWPART"`
High string `xml:"HIGHPART"`
}
var t time
err := d.DecodeElement(&t, &start)
if err != nil {
return err
}
low, err := strconv.ParseUint(t.Low, 0, 32)
if err != nil {
return err
}
high, err := strconv.ParseUint(t.High, 0, 32)
if err != nil {
return err
}
ft.LowDateTime = uint32(low)
ft.HighDateTime = uint32(high)
return nil
} | [
"func",
"(",
"ft",
"*",
"Filetime",
")",
"UnmarshalXML",
"(",
"d",
"*",
"xml",
".",
"Decoder",
",",
"start",
"xml",
".",
"StartElement",
")",
"error",
"{",
"type",
"time",
"struct",
"{",
"Low",
"string",
"`xml:\"LOWPART\"`",
"\n",
"High",
"string",
"`xml:\"HIGHPART\"`",
"\n",
"}",
"\n",
"var",
"t",
"time",
"\n",
"err",
":=",
"d",
".",
"DecodeElement",
"(",
"&",
"t",
",",
"&",
"start",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"low",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"t",
".",
"Low",
",",
"0",
",",
"32",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"high",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"t",
".",
"High",
",",
"0",
",",
"32",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"ft",
".",
"LowDateTime",
"=",
"uint32",
"(",
"low",
")",
"\n",
"ft",
".",
"HighDateTime",
"=",
"uint32",
"(",
"high",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalXML unmarshals the time from a WIM XML blob. | [
"UnmarshalXML",
"unmarshals",
"the",
"time",
"from",
"a",
"WIM",
"XML",
"blob",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L210-L233 |
150,695 | Microsoft/go-winio | wim/wim.go | NewReader | func NewReader(f io.ReaderAt) (*Reader, error) {
r := &Reader{r: f}
section := io.NewSectionReader(f, 0, 0xffff)
err := binary.Read(section, binary.LittleEndian, &r.hdr)
if err != nil {
return nil, err
}
if r.hdr.ImageTag != wimImageTag {
return nil, &ParseError{Oper: "image tag", Err: errors.New("not a WIM file")}
}
if r.hdr.Flags&^supportedHdrFlags != 0 {
return nil, fmt.Errorf("unsupported WIM flags %x", r.hdr.Flags&^supportedHdrFlags)
}
if r.hdr.CompressionSize != 0x8000 {
return nil, fmt.Errorf("unsupported compression size %d", r.hdr.CompressionSize)
}
if r.hdr.TotalParts != 1 {
return nil, errors.New("multi-part WIM not supported")
}
fileData, images, err := r.readOffsetTable(&r.hdr.OffsetTable)
if err != nil {
return nil, err
}
xmlinfo, err := r.readXML()
if err != nil {
return nil, err
}
var info info
err = xml.Unmarshal([]byte(xmlinfo), &info)
if err != nil {
return nil, &ParseError{Oper: "XML info", Err: err}
}
for i, img := range images {
for _, imgInfo := range info.Image {
if imgInfo.Index == i+1 {
img.ImageInfo = imgInfo
break
}
}
}
r.fileData = fileData
r.Image = images
r.XMLInfo = xmlinfo
return r, nil
} | go | func NewReader(f io.ReaderAt) (*Reader, error) {
r := &Reader{r: f}
section := io.NewSectionReader(f, 0, 0xffff)
err := binary.Read(section, binary.LittleEndian, &r.hdr)
if err != nil {
return nil, err
}
if r.hdr.ImageTag != wimImageTag {
return nil, &ParseError{Oper: "image tag", Err: errors.New("not a WIM file")}
}
if r.hdr.Flags&^supportedHdrFlags != 0 {
return nil, fmt.Errorf("unsupported WIM flags %x", r.hdr.Flags&^supportedHdrFlags)
}
if r.hdr.CompressionSize != 0x8000 {
return nil, fmt.Errorf("unsupported compression size %d", r.hdr.CompressionSize)
}
if r.hdr.TotalParts != 1 {
return nil, errors.New("multi-part WIM not supported")
}
fileData, images, err := r.readOffsetTable(&r.hdr.OffsetTable)
if err != nil {
return nil, err
}
xmlinfo, err := r.readXML()
if err != nil {
return nil, err
}
var info info
err = xml.Unmarshal([]byte(xmlinfo), &info)
if err != nil {
return nil, &ParseError{Oper: "XML info", Err: err}
}
for i, img := range images {
for _, imgInfo := range info.Image {
if imgInfo.Index == i+1 {
img.ImageInfo = imgInfo
break
}
}
}
r.fileData = fileData
r.Image = images
r.XMLInfo = xmlinfo
return r, nil
} | [
"func",
"NewReader",
"(",
"f",
"io",
".",
"ReaderAt",
")",
"(",
"*",
"Reader",
",",
"error",
")",
"{",
"r",
":=",
"&",
"Reader",
"{",
"r",
":",
"f",
"}",
"\n",
"section",
":=",
"io",
".",
"NewSectionReader",
"(",
"f",
",",
"0",
",",
"0xffff",
")",
"\n",
"err",
":=",
"binary",
".",
"Read",
"(",
"section",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"r",
".",
"hdr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"hdr",
".",
"ImageTag",
"!=",
"wimImageTag",
"{",
"return",
"nil",
",",
"&",
"ParseError",
"{",
"Oper",
":",
"\"",
"\"",
",",
"Err",
":",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"}",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"hdr",
".",
"Flags",
"&^",
"supportedHdrFlags",
"!=",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"r",
".",
"hdr",
".",
"Flags",
"&^",
"supportedHdrFlags",
")",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"hdr",
".",
"CompressionSize",
"!=",
"0x8000",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"r",
".",
"hdr",
".",
"CompressionSize",
")",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"hdr",
".",
"TotalParts",
"!=",
"1",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"fileData",
",",
"images",
",",
"err",
":=",
"r",
".",
"readOffsetTable",
"(",
"&",
"r",
".",
"hdr",
".",
"OffsetTable",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"xmlinfo",
",",
"err",
":=",
"r",
".",
"readXML",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"info",
"info",
"\n",
"err",
"=",
"xml",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"xmlinfo",
")",
",",
"&",
"info",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"&",
"ParseError",
"{",
"Oper",
":",
"\"",
"\"",
",",
"Err",
":",
"err",
"}",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"img",
":=",
"range",
"images",
"{",
"for",
"_",
",",
"imgInfo",
":=",
"range",
"info",
".",
"Image",
"{",
"if",
"imgInfo",
".",
"Index",
"==",
"i",
"+",
"1",
"{",
"img",
".",
"ImageInfo",
"=",
"imgInfo",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"r",
".",
"fileData",
"=",
"fileData",
"\n",
"r",
".",
"Image",
"=",
"images",
"\n",
"r",
".",
"XMLInfo",
"=",
"xmlinfo",
"\n",
"return",
"r",
",",
"nil",
"\n",
"}"
] | // NewReader returns a Reader that can be used to read WIM file data. | [
"NewReader",
"returns",
"a",
"Reader",
"that",
"can",
"be",
"used",
"to",
"read",
"WIM",
"file",
"data",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L347-L400 |
150,696 | Microsoft/go-winio | wim/wim.go | Close | func (r *Reader) Close() error {
for _, img := range r.Image {
img.reset()
}
return nil
} | go | func (r *Reader) Close() error {
for _, img := range r.Image {
img.reset()
}
return nil
} | [
"func",
"(",
"r",
"*",
"Reader",
")",
"Close",
"(",
")",
"error",
"{",
"for",
"_",
",",
"img",
":=",
"range",
"r",
".",
"Image",
"{",
"img",
".",
"reset",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close releases resources associated with the Reader. | [
"Close",
"releases",
"resources",
"associated",
"with",
"the",
"Reader",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L403-L408 |
150,697 | Microsoft/go-winio | wim/wim.go | Open | func (img *Image) Open() (*File, error) {
if img.sds == nil {
rsrc, err := img.wim.resourceReaderWithOffset(&img.offset, img.rootOffset)
if err != nil {
return nil, err
}
sds, n, err := img.wim.readSecurityDescriptors(rsrc)
if err != nil {
rsrc.Close()
return nil, err
}
img.sds = sds
img.r = rsrc
img.rootOffset = n
img.curOffset = n
}
f, err := img.readdir(img.rootOffset)
if err != nil {
return nil, err
}
if len(f) != 1 {
return nil, &ParseError{Oper: "root directory", Err: errors.New("expected exactly 1 root directory entry")}
}
return f[0], err
} | go | func (img *Image) Open() (*File, error) {
if img.sds == nil {
rsrc, err := img.wim.resourceReaderWithOffset(&img.offset, img.rootOffset)
if err != nil {
return nil, err
}
sds, n, err := img.wim.readSecurityDescriptors(rsrc)
if err != nil {
rsrc.Close()
return nil, err
}
img.sds = sds
img.r = rsrc
img.rootOffset = n
img.curOffset = n
}
f, err := img.readdir(img.rootOffset)
if err != nil {
return nil, err
}
if len(f) != 1 {
return nil, &ParseError{Oper: "root directory", Err: errors.New("expected exactly 1 root directory entry")}
}
return f[0], err
} | [
"func",
"(",
"img",
"*",
"Image",
")",
"Open",
"(",
")",
"(",
"*",
"File",
",",
"error",
")",
"{",
"if",
"img",
".",
"sds",
"==",
"nil",
"{",
"rsrc",
",",
"err",
":=",
"img",
".",
"wim",
".",
"resourceReaderWithOffset",
"(",
"&",
"img",
".",
"offset",
",",
"img",
".",
"rootOffset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"sds",
",",
"n",
",",
"err",
":=",
"img",
".",
"wim",
".",
"readSecurityDescriptors",
"(",
"rsrc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"rsrc",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"img",
".",
"sds",
"=",
"sds",
"\n",
"img",
".",
"r",
"=",
"rsrc",
"\n",
"img",
".",
"rootOffset",
"=",
"n",
"\n",
"img",
".",
"curOffset",
"=",
"n",
"\n",
"}",
"\n\n",
"f",
",",
"err",
":=",
"img",
".",
"readdir",
"(",
"img",
".",
"rootOffset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"f",
")",
"!=",
"1",
"{",
"return",
"nil",
",",
"&",
"ParseError",
"{",
"Oper",
":",
"\"",
"\"",
",",
"Err",
":",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"}",
"\n",
"}",
"\n",
"return",
"f",
"[",
"0",
"]",
",",
"err",
"\n",
"}"
] | // Open parses the image and returns the root directory. | [
"Open",
"parses",
"the",
"image",
"and",
"returns",
"the",
"root",
"directory",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L570-L595 |
150,698 | Microsoft/go-winio | wim/wim.go | Open | func (s *Stream) Open() (io.ReadCloser, error) {
return s.wim.resourceReader(&s.offset)
} | go | func (s *Stream) Open() (io.ReadCloser, error) {
return s.wim.resourceReader(&s.offset)
} | [
"func",
"(",
"s",
"*",
"Stream",
")",
"Open",
"(",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"return",
"s",
".",
"wim",
".",
"resourceReader",
"(",
"&",
"s",
".",
"offset",
")",
"\n",
"}"
] | // Open returns an io.ReadCloser that can be used to read the stream's contents. | [
"Open",
"returns",
"an",
"io",
".",
"ReadCloser",
"that",
"can",
"be",
"used",
"to",
"read",
"the",
"stream",
"s",
"contents",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L845-L847 |
150,699 | Microsoft/go-winio | wim/wim.go | Open | func (f *File) Open() (io.ReadCloser, error) {
return f.img.wim.resourceReader(&f.offset)
} | go | func (f *File) Open() (io.ReadCloser, error) {
return f.img.wim.resourceReader(&f.offset)
} | [
"func",
"(",
"f",
"*",
"File",
")",
"Open",
"(",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"return",
"f",
".",
"img",
".",
"wim",
".",
"resourceReader",
"(",
"&",
"f",
".",
"offset",
")",
"\n",
"}"
] | // Open returns an io.ReadCloser that can be used to read the file's contents. | [
"Open",
"returns",
"an",
"io",
".",
"ReadCloser",
"that",
"can",
"be",
"used",
"to",
"read",
"the",
"file",
"s",
"contents",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L850-L852 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.