repo
stringlengths 5
67
| path
stringlengths 4
218
| func_name
stringlengths 0
151
| original_string
stringlengths 52
373k
| language
stringclasses 6
values | code
stringlengths 52
373k
| code_tokens
listlengths 10
512
| docstring
stringlengths 3
47.2k
| docstring_tokens
listlengths 3
234
| sha
stringlengths 40
40
| url
stringlengths 85
339
| partition
stringclasses 3
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
vmware/govmomi
|
vapi/library/library_item_updatesession.go
|
WaitOnLibraryItemUpdateSession
|
func (c *Manager) WaitOnLibraryItemUpdateSession(
ctx context.Context, sessionID string,
interval time.Duration, intervalCallback func()) error {
// Wait until the upload operation is complete to return.
for {
session, err := c.GetLibraryItemUpdateSession(ctx, sessionID)
if err != nil {
return err
}
if session.State != "ACTIVE" {
return nil
}
time.Sleep(interval)
if intervalCallback != nil {
intervalCallback()
}
}
}
|
go
|
func (c *Manager) WaitOnLibraryItemUpdateSession(
ctx context.Context, sessionID string,
interval time.Duration, intervalCallback func()) error {
// Wait until the upload operation is complete to return.
for {
session, err := c.GetLibraryItemUpdateSession(ctx, sessionID)
if err != nil {
return err
}
if session.State != "ACTIVE" {
return nil
}
time.Sleep(interval)
if intervalCallback != nil {
intervalCallback()
}
}
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"WaitOnLibraryItemUpdateSession",
"(",
"ctx",
"context",
".",
"Context",
",",
"sessionID",
"string",
",",
"interval",
"time",
".",
"Duration",
",",
"intervalCallback",
"func",
"(",
")",
")",
"error",
"{",
"for",
"{",
"session",
",",
"err",
":=",
"c",
".",
"GetLibraryItemUpdateSession",
"(",
"ctx",
",",
"sessionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"session",
".",
"State",
"!=",
"\"ACTIVE\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"interval",
")",
"\n",
"if",
"intervalCallback",
"!=",
"nil",
"{",
"intervalCallback",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// WaitOnLibraryItemUpdateSession blocks until the update session is no longer
// in the ACTIVE state.
|
[
"WaitOnLibraryItemUpdateSession",
"blocks",
"until",
"the",
"update",
"session",
"is",
"no",
"longer",
"in",
"the",
"ACTIVE",
"state",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/library/library_item_updatesession.go#L98-L116
|
train
|
vmware/govmomi
|
sts/internal/types.go
|
toString
|
func (r *RequestSecurityToken) toString(c14n bool) string {
actas := ""
if r.ActAs != nil {
token := r.ActAs.Token
if c14n {
var a Assertion
err := Unmarshal([]byte(r.ActAs.Token), &a)
if err != nil {
log.Printf("decode ActAs: %s", err)
}
token = a.C14N()
}
actas = fmt.Sprintf(`<wst:ActAs xmlns:wst="http://docs.oasis-open.org/ws-sx/ws-trust/200802">%s</wst:ActAs>`, token)
}
body := []string{
fmt.Sprintf(`<RequestSecurityToken xmlns="http://docs.oasis-open.org/ws-sx/ws-trust/200512">`),
fmt.Sprintf(`<TokenType>%s</TokenType>`, r.TokenType),
fmt.Sprintf(`<RequestType>%s</RequestType>`, r.RequestType),
r.Lifetime.C14N(),
}
if r.RenewTarget == nil {
body = append(body,
fmt.Sprintf(`<Renewing Allow="%t" OK="%t"></Renewing>`, r.Renewing.Allow, r.Renewing.OK),
fmt.Sprintf(`<Delegatable>%t</Delegatable>`, r.Delegatable),
actas,
fmt.Sprintf(`<KeyType>%s</KeyType>`, r.KeyType),
fmt.Sprintf(`<SignatureAlgorithm>%s</SignatureAlgorithm>`, r.SignatureAlgorithm),
fmt.Sprintf(`<UseKey Sig="%s"></UseKey>`, r.UseKey.Sig))
} else {
token := r.RenewTarget.Token
if c14n {
var a Assertion
err := Unmarshal([]byte(r.RenewTarget.Token), &a)
if err != nil {
log.Printf("decode Renew: %s", err)
}
token = a.C14N()
}
body = append(body,
fmt.Sprintf(`<UseKey Sig="%s"></UseKey>`, r.UseKey.Sig),
fmt.Sprintf(`<RenewTarget>%s</RenewTarget>`, token))
}
return strings.Join(append(body, `</RequestSecurityToken>`), "")
}
|
go
|
func (r *RequestSecurityToken) toString(c14n bool) string {
actas := ""
if r.ActAs != nil {
token := r.ActAs.Token
if c14n {
var a Assertion
err := Unmarshal([]byte(r.ActAs.Token), &a)
if err != nil {
log.Printf("decode ActAs: %s", err)
}
token = a.C14N()
}
actas = fmt.Sprintf(`<wst:ActAs xmlns:wst="http://docs.oasis-open.org/ws-sx/ws-trust/200802">%s</wst:ActAs>`, token)
}
body := []string{
fmt.Sprintf(`<RequestSecurityToken xmlns="http://docs.oasis-open.org/ws-sx/ws-trust/200512">`),
fmt.Sprintf(`<TokenType>%s</TokenType>`, r.TokenType),
fmt.Sprintf(`<RequestType>%s</RequestType>`, r.RequestType),
r.Lifetime.C14N(),
}
if r.RenewTarget == nil {
body = append(body,
fmt.Sprintf(`<Renewing Allow="%t" OK="%t"></Renewing>`, r.Renewing.Allow, r.Renewing.OK),
fmt.Sprintf(`<Delegatable>%t</Delegatable>`, r.Delegatable),
actas,
fmt.Sprintf(`<KeyType>%s</KeyType>`, r.KeyType),
fmt.Sprintf(`<SignatureAlgorithm>%s</SignatureAlgorithm>`, r.SignatureAlgorithm),
fmt.Sprintf(`<UseKey Sig="%s"></UseKey>`, r.UseKey.Sig))
} else {
token := r.RenewTarget.Token
if c14n {
var a Assertion
err := Unmarshal([]byte(r.RenewTarget.Token), &a)
if err != nil {
log.Printf("decode Renew: %s", err)
}
token = a.C14N()
}
body = append(body,
fmt.Sprintf(`<UseKey Sig="%s"></UseKey>`, r.UseKey.Sig),
fmt.Sprintf(`<RenewTarget>%s</RenewTarget>`, token))
}
return strings.Join(append(body, `</RequestSecurityToken>`), "")
}
|
[
"func",
"(",
"r",
"*",
"RequestSecurityToken",
")",
"toString",
"(",
"c14n",
"bool",
")",
"string",
"{",
"actas",
":=",
"\"\"",
"\n",
"if",
"r",
".",
"ActAs",
"!=",
"nil",
"{",
"token",
":=",
"r",
".",
"ActAs",
".",
"Token",
"\n",
"if",
"c14n",
"{",
"var",
"a",
"Assertion",
"\n",
"err",
":=",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"r",
".",
"ActAs",
".",
"Token",
")",
",",
"&",
"a",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"decode ActAs: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"token",
"=",
"a",
".",
"C14N",
"(",
")",
"\n",
"}",
"\n",
"actas",
"=",
"fmt",
".",
"Sprintf",
"(",
"`<wst:ActAs xmlns:wst=\"http://docs.oasis-open.org/ws-sx/ws-trust/200802\">%s</wst:ActAs>`",
",",
"token",
")",
"\n",
"}",
"\n",
"body",
":=",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"`<RequestSecurityToken xmlns=\"http://docs.oasis-open.org/ws-sx/ws-trust/200512\">`",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"`<TokenType>%s</TokenType>`",
",",
"r",
".",
"TokenType",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"`<RequestType>%s</RequestType>`",
",",
"r",
".",
"RequestType",
")",
",",
"r",
".",
"Lifetime",
".",
"C14N",
"(",
")",
",",
"}",
"\n",
"if",
"r",
".",
"RenewTarget",
"==",
"nil",
"{",
"body",
"=",
"append",
"(",
"body",
",",
"fmt",
".",
"Sprintf",
"(",
"`<Renewing Allow=\"%t\" OK=\"%t\"></Renewing>`",
",",
"r",
".",
"Renewing",
".",
"Allow",
",",
"r",
".",
"Renewing",
".",
"OK",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"`<Delegatable>%t</Delegatable>`",
",",
"r",
".",
"Delegatable",
")",
",",
"actas",
",",
"fmt",
".",
"Sprintf",
"(",
"`<KeyType>%s</KeyType>`",
",",
"r",
".",
"KeyType",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"`<SignatureAlgorithm>%s</SignatureAlgorithm>`",
",",
"r",
".",
"SignatureAlgorithm",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"`<UseKey Sig=\"%s\"></UseKey>`",
",",
"r",
".",
"UseKey",
".",
"Sig",
")",
")",
"\n",
"}",
"else",
"{",
"token",
":=",
"r",
".",
"RenewTarget",
".",
"Token",
"\n",
"if",
"c14n",
"{",
"var",
"a",
"Assertion",
"\n",
"err",
":=",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"r",
".",
"RenewTarget",
".",
"Token",
")",
",",
"&",
"a",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"decode Renew: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"token",
"=",
"a",
".",
"C14N",
"(",
")",
"\n",
"}",
"\n",
"body",
"=",
"append",
"(",
"body",
",",
"fmt",
".",
"Sprintf",
"(",
"`<UseKey Sig=\"%s\"></UseKey>`",
",",
"r",
".",
"UseKey",
".",
"Sig",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"`<RenewTarget>%s</RenewTarget>`",
",",
"token",
")",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"append",
"(",
"body",
",",
"`</RequestSecurityToken>`",
")",
",",
"\"\"",
")",
"\n",
"}"
] |
// toString returns an XML encoded RequestSecurityToken.
// When c14n is true, returns the canonicalized ActAs.Assertion which is required to sign the Issue request.
// When c14n is false, returns the original content of the ActAs.Assertion.
// The original content must be used within the request Body, as it has its own signature.
|
[
"toString",
"returns",
"an",
"XML",
"encoded",
"RequestSecurityToken",
".",
"When",
"c14n",
"is",
"true",
"returns",
"the",
"canonicalized",
"ActAs",
".",
"Assertion",
"which",
"is",
"required",
"to",
"sign",
"the",
"Issue",
"request",
".",
"When",
"c14n",
"is",
"false",
"returns",
"the",
"original",
"content",
"of",
"the",
"ActAs",
".",
"Assertion",
".",
"The",
"original",
"content",
"must",
"be",
"used",
"within",
"the",
"request",
"Body",
"as",
"it",
"has",
"its",
"own",
"signature",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/sts/internal/types.go#L552-L600
|
train
|
vmware/govmomi
|
sts/internal/types.go
|
Marshal
|
func Marshal(val interface{}) string {
b, err := xml.Marshal(val)
if err != nil {
panic(err)
}
return string(b)
}
|
go
|
func Marshal(val interface{}) string {
b, err := xml.Marshal(val)
if err != nil {
panic(err)
}
return string(b)
}
|
[
"func",
"Marshal",
"(",
"val",
"interface",
"{",
"}",
")",
"string",
"{",
"b",
",",
"err",
":=",
"xml",
".",
"Marshal",
"(",
"val",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"string",
"(",
"b",
")",
"\n",
"}"
] |
// Marshal panics if xml.Marshal returns an error
|
[
"Marshal",
"panics",
"if",
"xml",
".",
"Marshal",
"returns",
"an",
"error"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/sts/internal/types.go#L673-L679
|
train
|
vmware/govmomi
|
sts/internal/types.go
|
mkns
|
func mkns(ns string, obj interface{}, name ...*xml.Name) string {
ns += ":"
for i := range name {
name[i].Space = ""
if !strings.HasPrefix(name[i].Local, ns) {
name[i].Local = ns + name[i].Local
}
}
return Marshal(obj)
}
|
go
|
func mkns(ns string, obj interface{}, name ...*xml.Name) string {
ns += ":"
for i := range name {
name[i].Space = ""
if !strings.HasPrefix(name[i].Local, ns) {
name[i].Local = ns + name[i].Local
}
}
return Marshal(obj)
}
|
[
"func",
"mkns",
"(",
"ns",
"string",
",",
"obj",
"interface",
"{",
"}",
",",
"name",
"...",
"*",
"xml",
".",
"Name",
")",
"string",
"{",
"ns",
"+=",
"\":\"",
"\n",
"for",
"i",
":=",
"range",
"name",
"{",
"name",
"[",
"i",
"]",
".",
"Space",
"=",
"\"\"",
"\n",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"name",
"[",
"i",
"]",
".",
"Local",
",",
"ns",
")",
"{",
"name",
"[",
"i",
"]",
".",
"Local",
"=",
"ns",
"+",
"name",
"[",
"i",
"]",
".",
"Local",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"Marshal",
"(",
"obj",
")",
"\n",
"}"
] |
// mkns prepends the given namespace to xml.Name.Local and returns obj encoded as xml.
// Note that the namespace is required when encoding, but the namespace prefix must not be
// present when decoding as Go's decoding does not handle namespace prefix.
|
[
"mkns",
"prepends",
"the",
"given",
"namespace",
"to",
"xml",
".",
"Name",
".",
"Local",
"and",
"returns",
"obj",
"encoded",
"as",
"xml",
".",
"Note",
"that",
"the",
"namespace",
"is",
"required",
"when",
"encoding",
"but",
"the",
"namespace",
"prefix",
"must",
"not",
"be",
"present",
"when",
"decoding",
"as",
"Go",
"s",
"decoding",
"does",
"not",
"handle",
"namespace",
"prefix",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/sts/internal/types.go#L684-L694
|
train
|
vmware/govmomi
|
view/container_view.go
|
Retrieve
|
func (v ContainerView) Retrieve(ctx context.Context, kind []string, ps []string, dst interface{}) error {
pc := property.DefaultCollector(v.Client())
ospec := types.ObjectSpec{
Obj: v.Reference(),
Skip: types.NewBool(true),
SelectSet: []types.BaseSelectionSpec{
&types.TraversalSpec{
Type: v.Reference().Type,
Path: "view",
},
},
}
var pspec []types.PropertySpec
if len(kind) == 0 {
kind = []string{"ManagedEntity"}
}
for _, t := range kind {
spec := types.PropertySpec{
Type: t,
}
if len(ps) == 0 {
spec.All = types.NewBool(true)
} else {
spec.PathSet = ps
}
pspec = append(pspec, spec)
}
req := types.RetrieveProperties{
SpecSet: []types.PropertyFilterSpec{
{
ObjectSet: []types.ObjectSpec{ospec},
PropSet: pspec,
},
},
}
res, err := pc.RetrieveProperties(ctx, req)
if err != nil {
return err
}
if d, ok := dst.(*[]types.ObjectContent); ok {
*d = res.Returnval
return nil
}
return mo.LoadRetrievePropertiesResponse(res, dst)
}
|
go
|
func (v ContainerView) Retrieve(ctx context.Context, kind []string, ps []string, dst interface{}) error {
pc := property.DefaultCollector(v.Client())
ospec := types.ObjectSpec{
Obj: v.Reference(),
Skip: types.NewBool(true),
SelectSet: []types.BaseSelectionSpec{
&types.TraversalSpec{
Type: v.Reference().Type,
Path: "view",
},
},
}
var pspec []types.PropertySpec
if len(kind) == 0 {
kind = []string{"ManagedEntity"}
}
for _, t := range kind {
spec := types.PropertySpec{
Type: t,
}
if len(ps) == 0 {
spec.All = types.NewBool(true)
} else {
spec.PathSet = ps
}
pspec = append(pspec, spec)
}
req := types.RetrieveProperties{
SpecSet: []types.PropertyFilterSpec{
{
ObjectSet: []types.ObjectSpec{ospec},
PropSet: pspec,
},
},
}
res, err := pc.RetrieveProperties(ctx, req)
if err != nil {
return err
}
if d, ok := dst.(*[]types.ObjectContent); ok {
*d = res.Returnval
return nil
}
return mo.LoadRetrievePropertiesResponse(res, dst)
}
|
[
"func",
"(",
"v",
"ContainerView",
")",
"Retrieve",
"(",
"ctx",
"context",
".",
"Context",
",",
"kind",
"[",
"]",
"string",
",",
"ps",
"[",
"]",
"string",
",",
"dst",
"interface",
"{",
"}",
")",
"error",
"{",
"pc",
":=",
"property",
".",
"DefaultCollector",
"(",
"v",
".",
"Client",
"(",
")",
")",
"\n",
"ospec",
":=",
"types",
".",
"ObjectSpec",
"{",
"Obj",
":",
"v",
".",
"Reference",
"(",
")",
",",
"Skip",
":",
"types",
".",
"NewBool",
"(",
"true",
")",
",",
"SelectSet",
":",
"[",
"]",
"types",
".",
"BaseSelectionSpec",
"{",
"&",
"types",
".",
"TraversalSpec",
"{",
"Type",
":",
"v",
".",
"Reference",
"(",
")",
".",
"Type",
",",
"Path",
":",
"\"view\"",
",",
"}",
",",
"}",
",",
"}",
"\n",
"var",
"pspec",
"[",
"]",
"types",
".",
"PropertySpec",
"\n",
"if",
"len",
"(",
"kind",
")",
"==",
"0",
"{",
"kind",
"=",
"[",
"]",
"string",
"{",
"\"ManagedEntity\"",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"t",
":=",
"range",
"kind",
"{",
"spec",
":=",
"types",
".",
"PropertySpec",
"{",
"Type",
":",
"t",
",",
"}",
"\n",
"if",
"len",
"(",
"ps",
")",
"==",
"0",
"{",
"spec",
".",
"All",
"=",
"types",
".",
"NewBool",
"(",
"true",
")",
"\n",
"}",
"else",
"{",
"spec",
".",
"PathSet",
"=",
"ps",
"\n",
"}",
"\n",
"pspec",
"=",
"append",
"(",
"pspec",
",",
"spec",
")",
"\n",
"}",
"\n",
"req",
":=",
"types",
".",
"RetrieveProperties",
"{",
"SpecSet",
":",
"[",
"]",
"types",
".",
"PropertyFilterSpec",
"{",
"{",
"ObjectSet",
":",
"[",
"]",
"types",
".",
"ObjectSpec",
"{",
"ospec",
"}",
",",
"PropSet",
":",
"pspec",
",",
"}",
",",
"}",
",",
"}",
"\n",
"res",
",",
"err",
":=",
"pc",
".",
"RetrieveProperties",
"(",
"ctx",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"d",
",",
"ok",
":=",
"dst",
".",
"(",
"*",
"[",
"]",
"types",
".",
"ObjectContent",
")",
";",
"ok",
"{",
"*",
"d",
"=",
"res",
".",
"Returnval",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"mo",
".",
"LoadRetrievePropertiesResponse",
"(",
"res",
",",
"dst",
")",
"\n",
"}"
] |
// Retrieve populates dst as property.Collector.Retrieve does, for all entities in the view of types specified by kind.
|
[
"Retrieve",
"populates",
"dst",
"as",
"property",
".",
"Collector",
".",
"Retrieve",
"does",
"for",
"all",
"entities",
"in",
"the",
"view",
"of",
"types",
"specified",
"by",
"kind",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/view/container_view.go#L39-L93
|
train
|
vmware/govmomi
|
view/container_view.go
|
Find
|
func (v ContainerView) Find(ctx context.Context, kind []string, filter property.Filter) ([]types.ManagedObjectReference, error) {
if len(filter) == 0 {
// Ensure we have at least 1 filter to avoid retrieving all properties.
filter = property.Filter{"name": "*"}
}
var content []types.ObjectContent
err := v.Retrieve(ctx, kind, filter.Keys(), &content)
if err != nil {
return nil, err
}
return filter.MatchObjectContent(content), nil
}
|
go
|
func (v ContainerView) Find(ctx context.Context, kind []string, filter property.Filter) ([]types.ManagedObjectReference, error) {
if len(filter) == 0 {
// Ensure we have at least 1 filter to avoid retrieving all properties.
filter = property.Filter{"name": "*"}
}
var content []types.ObjectContent
err := v.Retrieve(ctx, kind, filter.Keys(), &content)
if err != nil {
return nil, err
}
return filter.MatchObjectContent(content), nil
}
|
[
"func",
"(",
"v",
"ContainerView",
")",
"Find",
"(",
"ctx",
"context",
".",
"Context",
",",
"kind",
"[",
"]",
"string",
",",
"filter",
"property",
".",
"Filter",
")",
"(",
"[",
"]",
"types",
".",
"ManagedObjectReference",
",",
"error",
")",
"{",
"if",
"len",
"(",
"filter",
")",
"==",
"0",
"{",
"filter",
"=",
"property",
".",
"Filter",
"{",
"\"name\"",
":",
"\"*\"",
"}",
"\n",
"}",
"\n",
"var",
"content",
"[",
"]",
"types",
".",
"ObjectContent",
"\n",
"err",
":=",
"v",
".",
"Retrieve",
"(",
"ctx",
",",
"kind",
",",
"filter",
".",
"Keys",
"(",
")",
",",
"&",
"content",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"filter",
".",
"MatchObjectContent",
"(",
"content",
")",
",",
"nil",
"\n",
"}"
] |
// Find returns object references for entities of type kind, matching the given filter.
|
[
"Find",
"returns",
"object",
"references",
"for",
"entities",
"of",
"type",
"kind",
"matching",
"the",
"given",
"filter",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/view/container_view.go#L116-L130
|
train
|
vmware/govmomi
|
simulator/virtual_machine.go
|
updateDiskLayouts
|
func (vm *VirtualMachine) updateDiskLayouts() types.BaseMethodFault {
var disksLayout []types.VirtualMachineFileLayoutDiskLayout
var disksLayoutEx []types.VirtualMachineFileLayoutExDiskLayout
disks := object.VirtualDeviceList(vm.Config.Hardware.Device).SelectByType((*types.VirtualDisk)(nil))
for _, disk := range disks {
disk := disk.(*types.VirtualDisk)
diskBacking := disk.Backing.(*types.VirtualDiskFlatVer2BackingInfo)
diskLayout := &types.VirtualMachineFileLayoutDiskLayout{Key: disk.Key}
diskLayoutEx := &types.VirtualMachineFileLayoutExDiskLayout{Key: disk.Key}
// Iterate through disk and its parents
for {
dFileName := diskBacking.GetVirtualDeviceFileBackingInfo().FileName
var fileKeys []int32
dm := Map.VirtualDiskManager()
// Add disk descriptor and extent files
for _, diskName := range dm.names(dFileName) {
// get full path including datastore location
p, fault := parseDatastorePath(diskName)
if fault != nil {
return fault
}
datastore := vm.useDatastore(p.Datastore)
dFilePath := path.Join(datastore.Info.GetDatastoreInfo().Url, p.Path)
var fileSize int64
// If file can not be opened - fileSize will be 0
if dFileInfo, err := os.Stat(dFilePath); err == nil {
fileSize = dFileInfo.Size()
}
diskKey := vm.addFileLayoutEx(*p, fileSize)
fileKeys = append(fileKeys, diskKey)
}
diskLayout.DiskFile = append(diskLayout.DiskFile, dFileName)
diskLayoutEx.Chain = append(diskLayoutEx.Chain, types.VirtualMachineFileLayoutExDiskUnit{
FileKey: fileKeys,
})
if parent := diskBacking.Parent; parent != nil {
diskBacking = parent
} else {
break
}
}
disksLayout = append(disksLayout, *diskLayout)
disksLayoutEx = append(disksLayoutEx, *diskLayoutEx)
}
vm.Layout.Disk = disksLayout
vm.LayoutEx.Disk = disksLayoutEx
vm.LayoutEx.Timestamp = time.Now()
vm.updateStorage()
return nil
}
|
go
|
func (vm *VirtualMachine) updateDiskLayouts() types.BaseMethodFault {
var disksLayout []types.VirtualMachineFileLayoutDiskLayout
var disksLayoutEx []types.VirtualMachineFileLayoutExDiskLayout
disks := object.VirtualDeviceList(vm.Config.Hardware.Device).SelectByType((*types.VirtualDisk)(nil))
for _, disk := range disks {
disk := disk.(*types.VirtualDisk)
diskBacking := disk.Backing.(*types.VirtualDiskFlatVer2BackingInfo)
diskLayout := &types.VirtualMachineFileLayoutDiskLayout{Key: disk.Key}
diskLayoutEx := &types.VirtualMachineFileLayoutExDiskLayout{Key: disk.Key}
// Iterate through disk and its parents
for {
dFileName := diskBacking.GetVirtualDeviceFileBackingInfo().FileName
var fileKeys []int32
dm := Map.VirtualDiskManager()
// Add disk descriptor and extent files
for _, diskName := range dm.names(dFileName) {
// get full path including datastore location
p, fault := parseDatastorePath(diskName)
if fault != nil {
return fault
}
datastore := vm.useDatastore(p.Datastore)
dFilePath := path.Join(datastore.Info.GetDatastoreInfo().Url, p.Path)
var fileSize int64
// If file can not be opened - fileSize will be 0
if dFileInfo, err := os.Stat(dFilePath); err == nil {
fileSize = dFileInfo.Size()
}
diskKey := vm.addFileLayoutEx(*p, fileSize)
fileKeys = append(fileKeys, diskKey)
}
diskLayout.DiskFile = append(diskLayout.DiskFile, dFileName)
diskLayoutEx.Chain = append(diskLayoutEx.Chain, types.VirtualMachineFileLayoutExDiskUnit{
FileKey: fileKeys,
})
if parent := diskBacking.Parent; parent != nil {
diskBacking = parent
} else {
break
}
}
disksLayout = append(disksLayout, *diskLayout)
disksLayoutEx = append(disksLayoutEx, *diskLayoutEx)
}
vm.Layout.Disk = disksLayout
vm.LayoutEx.Disk = disksLayoutEx
vm.LayoutEx.Timestamp = time.Now()
vm.updateStorage()
return nil
}
|
[
"func",
"(",
"vm",
"*",
"VirtualMachine",
")",
"updateDiskLayouts",
"(",
")",
"types",
".",
"BaseMethodFault",
"{",
"var",
"disksLayout",
"[",
"]",
"types",
".",
"VirtualMachineFileLayoutDiskLayout",
"\n",
"var",
"disksLayoutEx",
"[",
"]",
"types",
".",
"VirtualMachineFileLayoutExDiskLayout",
"\n",
"disks",
":=",
"object",
".",
"VirtualDeviceList",
"(",
"vm",
".",
"Config",
".",
"Hardware",
".",
"Device",
")",
".",
"SelectByType",
"(",
"(",
"*",
"types",
".",
"VirtualDisk",
")",
"(",
"nil",
")",
")",
"\n",
"for",
"_",
",",
"disk",
":=",
"range",
"disks",
"{",
"disk",
":=",
"disk",
".",
"(",
"*",
"types",
".",
"VirtualDisk",
")",
"\n",
"diskBacking",
":=",
"disk",
".",
"Backing",
".",
"(",
"*",
"types",
".",
"VirtualDiskFlatVer2BackingInfo",
")",
"\n",
"diskLayout",
":=",
"&",
"types",
".",
"VirtualMachineFileLayoutDiskLayout",
"{",
"Key",
":",
"disk",
".",
"Key",
"}",
"\n",
"diskLayoutEx",
":=",
"&",
"types",
".",
"VirtualMachineFileLayoutExDiskLayout",
"{",
"Key",
":",
"disk",
".",
"Key",
"}",
"\n",
"for",
"{",
"dFileName",
":=",
"diskBacking",
".",
"GetVirtualDeviceFileBackingInfo",
"(",
")",
".",
"FileName",
"\n",
"var",
"fileKeys",
"[",
"]",
"int32",
"\n",
"dm",
":=",
"Map",
".",
"VirtualDiskManager",
"(",
")",
"\n",
"for",
"_",
",",
"diskName",
":=",
"range",
"dm",
".",
"names",
"(",
"dFileName",
")",
"{",
"p",
",",
"fault",
":=",
"parseDatastorePath",
"(",
"diskName",
")",
"\n",
"if",
"fault",
"!=",
"nil",
"{",
"return",
"fault",
"\n",
"}",
"\n",
"datastore",
":=",
"vm",
".",
"useDatastore",
"(",
"p",
".",
"Datastore",
")",
"\n",
"dFilePath",
":=",
"path",
".",
"Join",
"(",
"datastore",
".",
"Info",
".",
"GetDatastoreInfo",
"(",
")",
".",
"Url",
",",
"p",
".",
"Path",
")",
"\n",
"var",
"fileSize",
"int64",
"\n",
"if",
"dFileInfo",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"dFilePath",
")",
";",
"err",
"==",
"nil",
"{",
"fileSize",
"=",
"dFileInfo",
".",
"Size",
"(",
")",
"\n",
"}",
"\n",
"diskKey",
":=",
"vm",
".",
"addFileLayoutEx",
"(",
"*",
"p",
",",
"fileSize",
")",
"\n",
"fileKeys",
"=",
"append",
"(",
"fileKeys",
",",
"diskKey",
")",
"\n",
"}",
"\n",
"diskLayout",
".",
"DiskFile",
"=",
"append",
"(",
"diskLayout",
".",
"DiskFile",
",",
"dFileName",
")",
"\n",
"diskLayoutEx",
".",
"Chain",
"=",
"append",
"(",
"diskLayoutEx",
".",
"Chain",
",",
"types",
".",
"VirtualMachineFileLayoutExDiskUnit",
"{",
"FileKey",
":",
"fileKeys",
",",
"}",
")",
"\n",
"if",
"parent",
":=",
"diskBacking",
".",
"Parent",
";",
"parent",
"!=",
"nil",
"{",
"diskBacking",
"=",
"parent",
"\n",
"}",
"else",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"disksLayout",
"=",
"append",
"(",
"disksLayout",
",",
"*",
"diskLayout",
")",
"\n",
"disksLayoutEx",
"=",
"append",
"(",
"disksLayoutEx",
",",
"*",
"diskLayoutEx",
")",
"\n",
"}",
"\n",
"vm",
".",
"Layout",
".",
"Disk",
"=",
"disksLayout",
"\n",
"vm",
".",
"LayoutEx",
".",
"Disk",
"=",
"disksLayoutEx",
"\n",
"vm",
".",
"LayoutEx",
".",
"Timestamp",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"vm",
".",
"updateStorage",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Updates both vm.Layout.Disk and vm.LayoutEx.Disk
|
[
"Updates",
"both",
"vm",
".",
"Layout",
".",
"Disk",
"and",
"vm",
".",
"LayoutEx",
".",
"Disk"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/virtual_machine.go#L519-L583
|
train
|
vmware/govmomi
|
govc/flags/output.go
|
Log
|
func (flag *OutputFlag) Log(s string) (int, error) {
if len(s) > 0 && s[0] == '\r' {
flag.Write([]byte{'\r', 033, '[', 'K'})
s = s[1:]
}
return flag.WriteString(time.Now().Format("[02-01-06 15:04:05] ") + s)
}
|
go
|
func (flag *OutputFlag) Log(s string) (int, error) {
if len(s) > 0 && s[0] == '\r' {
flag.Write([]byte{'\r', 033, '[', 'K'})
s = s[1:]
}
return flag.WriteString(time.Now().Format("[02-01-06 15:04:05] ") + s)
}
|
[
"func",
"(",
"flag",
"*",
"OutputFlag",
")",
"Log",
"(",
"s",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"len",
"(",
"s",
")",
">",
"0",
"&&",
"s",
"[",
"0",
"]",
"==",
"'\\r'",
"{",
"flag",
".",
"Write",
"(",
"[",
"]",
"byte",
"{",
"'\\r'",
",",
"033",
",",
"'['",
",",
"'K'",
"}",
")",
"\n",
"s",
"=",
"s",
"[",
"1",
":",
"]",
"\n",
"}",
"\n",
"return",
"flag",
".",
"WriteString",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Format",
"(",
"\"[02-01-06 15:04:05] \"",
")",
"+",
"s",
")",
"\n",
"}"
] |
// Log outputs the specified string, prefixed with the current time.
// A newline is not automatically added. If the specified string
// starts with a '\r', the current line is cleared first.
|
[
"Log",
"outputs",
"the",
"specified",
"string",
"prefixed",
"with",
"the",
"current",
"time",
".",
"A",
"newline",
"is",
"not",
"automatically",
"added",
".",
"If",
"the",
"specified",
"string",
"starts",
"with",
"a",
"\\",
"r",
"the",
"current",
"line",
"is",
"cleared",
"first",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/govc/flags/output.go#L80-L87
|
train
|
vmware/govmomi
|
vim25/mo/retrieve.go
|
ObjectContentToType
|
func ObjectContentToType(o types.ObjectContent) (interface{}, error) {
// Expect no properties in the missing set
for _, p := range o.MissingSet {
if ignoreMissingProperty(o.Obj, p) {
continue
}
return nil, soap.WrapVimFault(p.Fault.Fault)
}
ti := typeInfoForType(o.Obj.Type)
v, err := ti.LoadFromObjectContent(o)
if err != nil {
return nil, err
}
return v.Elem().Interface(), nil
}
|
go
|
func ObjectContentToType(o types.ObjectContent) (interface{}, error) {
// Expect no properties in the missing set
for _, p := range o.MissingSet {
if ignoreMissingProperty(o.Obj, p) {
continue
}
return nil, soap.WrapVimFault(p.Fault.Fault)
}
ti := typeInfoForType(o.Obj.Type)
v, err := ti.LoadFromObjectContent(o)
if err != nil {
return nil, err
}
return v.Elem().Interface(), nil
}
|
[
"func",
"ObjectContentToType",
"(",
"o",
"types",
".",
"ObjectContent",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"o",
".",
"MissingSet",
"{",
"if",
"ignoreMissingProperty",
"(",
"o",
".",
"Obj",
",",
"p",
")",
"{",
"continue",
"\n",
"}",
"\n",
"return",
"nil",
",",
"soap",
".",
"WrapVimFault",
"(",
"p",
".",
"Fault",
".",
"Fault",
")",
"\n",
"}",
"\n",
"ti",
":=",
"typeInfoForType",
"(",
"o",
".",
"Obj",
".",
"Type",
")",
"\n",
"v",
",",
"err",
":=",
"ti",
".",
"LoadFromObjectContent",
"(",
"o",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"v",
".",
"Elem",
"(",
")",
".",
"Interface",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// ObjectContentToType loads an ObjectContent value into the value it
// represents. If the ObjectContent value has a non-empty 'MissingSet' field,
// it returns the first fault it finds there as error. If the 'MissingSet'
// field is empty, it returns a pointer to a reflect.Value. It handles contain
// nested properties, such as 'guest.ipAddress' or 'config.hardware'.
|
[
"ObjectContentToType",
"loads",
"an",
"ObjectContent",
"value",
"into",
"the",
"value",
"it",
"represents",
".",
"If",
"the",
"ObjectContent",
"value",
"has",
"a",
"non",
"-",
"empty",
"MissingSet",
"field",
"it",
"returns",
"the",
"first",
"fault",
"it",
"finds",
"there",
"as",
"error",
".",
"If",
"the",
"MissingSet",
"field",
"is",
"empty",
"it",
"returns",
"a",
"pointer",
"to",
"a",
"reflect",
".",
"Value",
".",
"It",
"handles",
"contain",
"nested",
"properties",
"such",
"as",
"guest",
".",
"ipAddress",
"or",
"config",
".",
"hardware",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/mo/retrieve.go#L49-L66
|
train
|
vmware/govmomi
|
vim25/mo/retrieve.go
|
ApplyPropertyChange
|
func ApplyPropertyChange(obj Reference, changes []types.PropertyChange) {
t := typeInfoForType(obj.Reference().Type)
v := reflect.ValueOf(obj)
for _, p := range changes {
rv, ok := t.props[p.Name]
if !ok {
continue
}
assignValue(v, rv, reflect.ValueOf(p.Val))
}
}
|
go
|
func ApplyPropertyChange(obj Reference, changes []types.PropertyChange) {
t := typeInfoForType(obj.Reference().Type)
v := reflect.ValueOf(obj)
for _, p := range changes {
rv, ok := t.props[p.Name]
if !ok {
continue
}
assignValue(v, rv, reflect.ValueOf(p.Val))
}
}
|
[
"func",
"ApplyPropertyChange",
"(",
"obj",
"Reference",
",",
"changes",
"[",
"]",
"types",
".",
"PropertyChange",
")",
"{",
"t",
":=",
"typeInfoForType",
"(",
"obj",
".",
"Reference",
"(",
")",
".",
"Type",
")",
"\n",
"v",
":=",
"reflect",
".",
"ValueOf",
"(",
"obj",
")",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"changes",
"{",
"rv",
",",
"ok",
":=",
"t",
".",
"props",
"[",
"p",
".",
"Name",
"]",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"assignValue",
"(",
"v",
",",
"rv",
",",
"reflect",
".",
"ValueOf",
"(",
"p",
".",
"Val",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// ApplyPropertyChange converts the response of a call to WaitForUpdates
// and applies it to the given managed object.
|
[
"ApplyPropertyChange",
"converts",
"the",
"response",
"of",
"a",
"call",
"to",
"WaitForUpdates",
"and",
"applies",
"it",
"to",
"the",
"given",
"managed",
"object",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/mo/retrieve.go#L70-L82
|
train
|
vmware/govmomi
|
vim25/mo/retrieve.go
|
LoadRetrievePropertiesResponse
|
func LoadRetrievePropertiesResponse(res *types.RetrievePropertiesResponse, dst interface{}) error {
rt := reflect.TypeOf(dst)
if rt == nil || rt.Kind() != reflect.Ptr {
panic("need pointer")
}
rv := reflect.ValueOf(dst).Elem()
if !rv.CanSet() {
panic("cannot set dst")
}
isSlice := false
switch rt.Elem().Kind() {
case reflect.Struct:
case reflect.Slice:
isSlice = true
default:
panic("unexpected type")
}
if isSlice {
for _, p := range res.Returnval {
v, err := ObjectContentToType(p)
if err != nil {
return err
}
vt := reflect.TypeOf(v)
if !rv.Type().AssignableTo(vt) {
// For example: dst is []ManagedEntity, res is []HostSystem
if field, ok := vt.FieldByName(rt.Elem().Elem().Name()); ok && field.Anonymous {
rv.Set(reflect.Append(rv, reflect.ValueOf(v).FieldByIndex(field.Index)))
continue
}
}
rv.Set(reflect.Append(rv, reflect.ValueOf(v)))
}
} else {
switch len(res.Returnval) {
case 0:
case 1:
v, err := ObjectContentToType(res.Returnval[0])
if err != nil {
return err
}
vt := reflect.TypeOf(v)
if !rv.Type().AssignableTo(vt) {
// For example: dst is ComputeResource, res is ClusterComputeResource
if field, ok := vt.FieldByName(rt.Elem().Name()); ok && field.Anonymous {
rv.Set(reflect.ValueOf(v).FieldByIndex(field.Index))
return nil
}
}
rv.Set(reflect.ValueOf(v))
default:
// If dst is not a slice, expect to receive 0 or 1 results
panic("more than 1 result")
}
}
return nil
}
|
go
|
func LoadRetrievePropertiesResponse(res *types.RetrievePropertiesResponse, dst interface{}) error {
rt := reflect.TypeOf(dst)
if rt == nil || rt.Kind() != reflect.Ptr {
panic("need pointer")
}
rv := reflect.ValueOf(dst).Elem()
if !rv.CanSet() {
panic("cannot set dst")
}
isSlice := false
switch rt.Elem().Kind() {
case reflect.Struct:
case reflect.Slice:
isSlice = true
default:
panic("unexpected type")
}
if isSlice {
for _, p := range res.Returnval {
v, err := ObjectContentToType(p)
if err != nil {
return err
}
vt := reflect.TypeOf(v)
if !rv.Type().AssignableTo(vt) {
// For example: dst is []ManagedEntity, res is []HostSystem
if field, ok := vt.FieldByName(rt.Elem().Elem().Name()); ok && field.Anonymous {
rv.Set(reflect.Append(rv, reflect.ValueOf(v).FieldByIndex(field.Index)))
continue
}
}
rv.Set(reflect.Append(rv, reflect.ValueOf(v)))
}
} else {
switch len(res.Returnval) {
case 0:
case 1:
v, err := ObjectContentToType(res.Returnval[0])
if err != nil {
return err
}
vt := reflect.TypeOf(v)
if !rv.Type().AssignableTo(vt) {
// For example: dst is ComputeResource, res is ClusterComputeResource
if field, ok := vt.FieldByName(rt.Elem().Name()); ok && field.Anonymous {
rv.Set(reflect.ValueOf(v).FieldByIndex(field.Index))
return nil
}
}
rv.Set(reflect.ValueOf(v))
default:
// If dst is not a slice, expect to receive 0 or 1 results
panic("more than 1 result")
}
}
return nil
}
|
[
"func",
"LoadRetrievePropertiesResponse",
"(",
"res",
"*",
"types",
".",
"RetrievePropertiesResponse",
",",
"dst",
"interface",
"{",
"}",
")",
"error",
"{",
"rt",
":=",
"reflect",
".",
"TypeOf",
"(",
"dst",
")",
"\n",
"if",
"rt",
"==",
"nil",
"||",
"rt",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"{",
"panic",
"(",
"\"need pointer\"",
")",
"\n",
"}",
"\n",
"rv",
":=",
"reflect",
".",
"ValueOf",
"(",
"dst",
")",
".",
"Elem",
"(",
")",
"\n",
"if",
"!",
"rv",
".",
"CanSet",
"(",
")",
"{",
"panic",
"(",
"\"cannot set dst\"",
")",
"\n",
"}",
"\n",
"isSlice",
":=",
"false",
"\n",
"switch",
"rt",
".",
"Elem",
"(",
")",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Struct",
":",
"case",
"reflect",
".",
"Slice",
":",
"isSlice",
"=",
"true",
"\n",
"default",
":",
"panic",
"(",
"\"unexpected type\"",
")",
"\n",
"}",
"\n",
"if",
"isSlice",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"res",
".",
"Returnval",
"{",
"v",
",",
"err",
":=",
"ObjectContentToType",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"vt",
":=",
"reflect",
".",
"TypeOf",
"(",
"v",
")",
"\n",
"if",
"!",
"rv",
".",
"Type",
"(",
")",
".",
"AssignableTo",
"(",
"vt",
")",
"{",
"if",
"field",
",",
"ok",
":=",
"vt",
".",
"FieldByName",
"(",
"rt",
".",
"Elem",
"(",
")",
".",
"Elem",
"(",
")",
".",
"Name",
"(",
")",
")",
";",
"ok",
"&&",
"field",
".",
"Anonymous",
"{",
"rv",
".",
"Set",
"(",
"reflect",
".",
"Append",
"(",
"rv",
",",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
".",
"FieldByIndex",
"(",
"field",
".",
"Index",
")",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"rv",
".",
"Set",
"(",
"reflect",
".",
"Append",
"(",
"rv",
",",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"switch",
"len",
"(",
"res",
".",
"Returnval",
")",
"{",
"case",
"0",
":",
"case",
"1",
":",
"v",
",",
"err",
":=",
"ObjectContentToType",
"(",
"res",
".",
"Returnval",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"vt",
":=",
"reflect",
".",
"TypeOf",
"(",
"v",
")",
"\n",
"if",
"!",
"rv",
".",
"Type",
"(",
")",
".",
"AssignableTo",
"(",
"vt",
")",
"{",
"if",
"field",
",",
"ok",
":=",
"vt",
".",
"FieldByName",
"(",
"rt",
".",
"Elem",
"(",
")",
".",
"Name",
"(",
")",
")",
";",
"ok",
"&&",
"field",
".",
"Anonymous",
"{",
"rv",
".",
"Set",
"(",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
".",
"FieldByIndex",
"(",
"field",
".",
"Index",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"rv",
".",
"Set",
"(",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
")",
"\n",
"default",
":",
"panic",
"(",
"\"more than 1 result\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// LoadRetrievePropertiesResponse converts the response of a call to
// RetrieveProperties to one or more managed objects.
|
[
"LoadRetrievePropertiesResponse",
"converts",
"the",
"response",
"of",
"a",
"call",
"to",
"RetrieveProperties",
"to",
"one",
"or",
"more",
"managed",
"objects",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/mo/retrieve.go#L86-L152
|
train
|
vmware/govmomi
|
vim25/mo/retrieve.go
|
RetrievePropertiesForRequest
|
func RetrievePropertiesForRequest(ctx context.Context, r soap.RoundTripper, req types.RetrieveProperties, dst interface{}) error {
res, err := methods.RetrieveProperties(ctx, r, &req)
if err != nil {
return err
}
return LoadRetrievePropertiesResponse(res, dst)
}
|
go
|
func RetrievePropertiesForRequest(ctx context.Context, r soap.RoundTripper, req types.RetrieveProperties, dst interface{}) error {
res, err := methods.RetrieveProperties(ctx, r, &req)
if err != nil {
return err
}
return LoadRetrievePropertiesResponse(res, dst)
}
|
[
"func",
"RetrievePropertiesForRequest",
"(",
"ctx",
"context",
".",
"Context",
",",
"r",
"soap",
".",
"RoundTripper",
",",
"req",
"types",
".",
"RetrieveProperties",
",",
"dst",
"interface",
"{",
"}",
")",
"error",
"{",
"res",
",",
"err",
":=",
"methods",
".",
"RetrieveProperties",
"(",
"ctx",
",",
"r",
",",
"&",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"LoadRetrievePropertiesResponse",
"(",
"res",
",",
"dst",
")",
"\n",
"}"
] |
// RetrievePropertiesForRequest calls the RetrieveProperties method with the
// specified request and decodes the response struct into the value pointed to
// by dst.
|
[
"RetrievePropertiesForRequest",
"calls",
"the",
"RetrieveProperties",
"method",
"with",
"the",
"specified",
"request",
"and",
"decodes",
"the",
"response",
"struct",
"into",
"the",
"value",
"pointed",
"to",
"by",
"dst",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/mo/retrieve.go#L157-L164
|
train
|
vmware/govmomi
|
vim25/mo/retrieve.go
|
RetrieveProperties
|
func RetrieveProperties(ctx context.Context, r soap.RoundTripper, pc, obj types.ManagedObjectReference, dst interface{}) error {
req := types.RetrieveProperties{
This: pc,
SpecSet: []types.PropertyFilterSpec{
{
ObjectSet: []types.ObjectSpec{
{
Obj: obj,
Skip: types.NewBool(false),
},
},
PropSet: []types.PropertySpec{
{
All: types.NewBool(true),
Type: obj.Type,
},
},
},
},
}
return RetrievePropertiesForRequest(ctx, r, req, dst)
}
|
go
|
func RetrieveProperties(ctx context.Context, r soap.RoundTripper, pc, obj types.ManagedObjectReference, dst interface{}) error {
req := types.RetrieveProperties{
This: pc,
SpecSet: []types.PropertyFilterSpec{
{
ObjectSet: []types.ObjectSpec{
{
Obj: obj,
Skip: types.NewBool(false),
},
},
PropSet: []types.PropertySpec{
{
All: types.NewBool(true),
Type: obj.Type,
},
},
},
},
}
return RetrievePropertiesForRequest(ctx, r, req, dst)
}
|
[
"func",
"RetrieveProperties",
"(",
"ctx",
"context",
".",
"Context",
",",
"r",
"soap",
".",
"RoundTripper",
",",
"pc",
",",
"obj",
"types",
".",
"ManagedObjectReference",
",",
"dst",
"interface",
"{",
"}",
")",
"error",
"{",
"req",
":=",
"types",
".",
"RetrieveProperties",
"{",
"This",
":",
"pc",
",",
"SpecSet",
":",
"[",
"]",
"types",
".",
"PropertyFilterSpec",
"{",
"{",
"ObjectSet",
":",
"[",
"]",
"types",
".",
"ObjectSpec",
"{",
"{",
"Obj",
":",
"obj",
",",
"Skip",
":",
"types",
".",
"NewBool",
"(",
"false",
")",
",",
"}",
",",
"}",
",",
"PropSet",
":",
"[",
"]",
"types",
".",
"PropertySpec",
"{",
"{",
"All",
":",
"types",
".",
"NewBool",
"(",
"true",
")",
",",
"Type",
":",
"obj",
".",
"Type",
",",
"}",
",",
"}",
",",
"}",
",",
"}",
",",
"}",
"\n",
"return",
"RetrievePropertiesForRequest",
"(",
"ctx",
",",
"r",
",",
"req",
",",
"dst",
")",
"\n",
"}"
] |
// RetrieveProperties retrieves the properties of the managed object specified
// as obj and decodes the response struct into the value pointed to by dst.
|
[
"RetrieveProperties",
"retrieves",
"the",
"properties",
"of",
"the",
"managed",
"object",
"specified",
"as",
"obj",
"and",
"decodes",
"the",
"response",
"struct",
"into",
"the",
"value",
"pointed",
"to",
"by",
"dst",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/mo/retrieve.go#L168-L190
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
NewServer
|
func NewServer() *Server {
if f := flag.Lookup("toolbox.trace"); f != nil {
Trace, _ = strconv.ParseBool(f.Value.String())
}
s := &Server{
sessions: make(map[uint64]*session),
schemes: make(map[string]FileHandler),
chmod: os.Chmod,
chown: os.Chown,
}
s.handlers = map[int32]func(*Packet) (interface{}, error){
OpCreateSessionV4: s.CreateSessionV4,
OpDestroySessionV4: s.DestroySessionV4,
OpGetattrV2: s.GetattrV2,
OpSetattrV2: s.SetattrV2,
OpOpen: s.Open,
OpClose: s.Close,
OpOpenV3: s.OpenV3,
OpReadV3: s.ReadV3,
OpWriteV3: s.WriteV3,
}
for op := range s.handlers {
s.Capabilities = append(s.Capabilities, Capability{Op: op, Flags: 0x1})
}
return s
}
|
go
|
func NewServer() *Server {
if f := flag.Lookup("toolbox.trace"); f != nil {
Trace, _ = strconv.ParseBool(f.Value.String())
}
s := &Server{
sessions: make(map[uint64]*session),
schemes: make(map[string]FileHandler),
chmod: os.Chmod,
chown: os.Chown,
}
s.handlers = map[int32]func(*Packet) (interface{}, error){
OpCreateSessionV4: s.CreateSessionV4,
OpDestroySessionV4: s.DestroySessionV4,
OpGetattrV2: s.GetattrV2,
OpSetattrV2: s.SetattrV2,
OpOpen: s.Open,
OpClose: s.Close,
OpOpenV3: s.OpenV3,
OpReadV3: s.ReadV3,
OpWriteV3: s.WriteV3,
}
for op := range s.handlers {
s.Capabilities = append(s.Capabilities, Capability{Op: op, Flags: 0x1})
}
return s
}
|
[
"func",
"NewServer",
"(",
")",
"*",
"Server",
"{",
"if",
"f",
":=",
"flag",
".",
"Lookup",
"(",
"\"toolbox.trace\"",
")",
";",
"f",
"!=",
"nil",
"{",
"Trace",
",",
"_",
"=",
"strconv",
".",
"ParseBool",
"(",
"f",
".",
"Value",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"s",
":=",
"&",
"Server",
"{",
"sessions",
":",
"make",
"(",
"map",
"[",
"uint64",
"]",
"*",
"session",
")",
",",
"schemes",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"FileHandler",
")",
",",
"chmod",
":",
"os",
".",
"Chmod",
",",
"chown",
":",
"os",
".",
"Chown",
",",
"}",
"\n",
"s",
".",
"handlers",
"=",
"map",
"[",
"int32",
"]",
"func",
"(",
"*",
"Packet",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"OpCreateSessionV4",
":",
"s",
".",
"CreateSessionV4",
",",
"OpDestroySessionV4",
":",
"s",
".",
"DestroySessionV4",
",",
"OpGetattrV2",
":",
"s",
".",
"GetattrV2",
",",
"OpSetattrV2",
":",
"s",
".",
"SetattrV2",
",",
"OpOpen",
":",
"s",
".",
"Open",
",",
"OpClose",
":",
"s",
".",
"Close",
",",
"OpOpenV3",
":",
"s",
".",
"OpenV3",
",",
"OpReadV3",
":",
"s",
".",
"ReadV3",
",",
"OpWriteV3",
":",
"s",
".",
"WriteV3",
",",
"}",
"\n",
"for",
"op",
":=",
"range",
"s",
".",
"handlers",
"{",
"s",
".",
"Capabilities",
"=",
"append",
"(",
"s",
".",
"Capabilities",
",",
"Capability",
"{",
"Op",
":",
"op",
",",
"Flags",
":",
"0x1",
"}",
")",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] |
// NewServer creates a new Server instance with the default handlers
|
[
"NewServer",
"creates",
"a",
"new",
"Server",
"instance",
"with",
"the",
"default",
"handlers"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L57-L86
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
RegisterFileHandler
|
func (s *Server) RegisterFileHandler(scheme string, handler FileHandler) {
if handler == nil {
delete(s.schemes, scheme)
return
}
s.schemes[scheme] = handler
}
|
go
|
func (s *Server) RegisterFileHandler(scheme string, handler FileHandler) {
if handler == nil {
delete(s.schemes, scheme)
return
}
s.schemes[scheme] = handler
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"RegisterFileHandler",
"(",
"scheme",
"string",
",",
"handler",
"FileHandler",
")",
"{",
"if",
"handler",
"==",
"nil",
"{",
"delete",
"(",
"s",
".",
"schemes",
",",
"scheme",
")",
"\n",
"return",
"\n",
"}",
"\n",
"s",
".",
"schemes",
"[",
"scheme",
"]",
"=",
"handler",
"\n",
"}"
] |
// RegisterFileHandler enables dispatch to handler for the given scheme.
|
[
"RegisterFileHandler",
"enables",
"dispatch",
"to",
"handler",
"for",
"the",
"given",
"scheme",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L89-L95
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
Dispatch
|
func (s *Server) Dispatch(packet []byte) ([]byte, error) {
req := &Packet{}
err := req.UnmarshalBinary(packet)
if err != nil {
return nil, err
}
if Trace {
fmt.Fprintf(os.Stderr, "[hgfs] request %#v\n", req.Header)
}
var res interface{}
handler, ok := s.handlers[req.Op]
if ok {
res, err = handler(req)
} else {
err = &Status{
Code: StatusOperationNotSupported,
Err: fmt.Errorf("unsupported Op(%d)", req.Op),
}
}
return req.Reply(res, err)
}
|
go
|
func (s *Server) Dispatch(packet []byte) ([]byte, error) {
req := &Packet{}
err := req.UnmarshalBinary(packet)
if err != nil {
return nil, err
}
if Trace {
fmt.Fprintf(os.Stderr, "[hgfs] request %#v\n", req.Header)
}
var res interface{}
handler, ok := s.handlers[req.Op]
if ok {
res, err = handler(req)
} else {
err = &Status{
Code: StatusOperationNotSupported,
Err: fmt.Errorf("unsupported Op(%d)", req.Op),
}
}
return req.Reply(res, err)
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"Dispatch",
"(",
"packet",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"req",
":=",
"&",
"Packet",
"{",
"}",
"\n",
"err",
":=",
"req",
".",
"UnmarshalBinary",
"(",
"packet",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"Trace",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"[hgfs] request %#v\\n\"",
",",
"\\n",
")",
"\n",
"}",
"\n",
"req",
".",
"Header",
"\n",
"var",
"res",
"interface",
"{",
"}",
"\n",
"handler",
",",
"ok",
":=",
"s",
".",
"handlers",
"[",
"req",
".",
"Op",
"]",
"\n",
"if",
"ok",
"{",
"res",
",",
"err",
"=",
"handler",
"(",
"req",
")",
"\n",
"}",
"else",
"{",
"err",
"=",
"&",
"Status",
"{",
"Code",
":",
"StatusOperationNotSupported",
",",
"Err",
":",
"fmt",
".",
"Errorf",
"(",
"\"unsupported Op(%d)\"",
",",
"req",
".",
"Op",
")",
",",
"}",
"\n",
"}",
"\n",
"}"
] |
// Dispatch unpacks the given request packet and dispatches to the appropriate handler
|
[
"Dispatch",
"unpacks",
"the",
"given",
"request",
"packet",
"and",
"dispatches",
"to",
"the",
"appropriate",
"handler"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L98-L123
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
urlParse
|
func urlParse(name string) *url.URL {
var info os.FileInfo
u, err := url.Parse(name)
if err == nil && u.Scheme == "" {
info, err = os.Stat(u.Path)
if err == nil && info.IsDir() {
u.Scheme = ArchiveScheme // special case for IsDir()
return u
}
}
u, err = url.Parse(strings.TrimPrefix(name, "/")) // must appear to be an absolute path or hgfs errors
if err != nil {
u = &url.URL{Path: name}
}
if u.Scheme == "" {
ix := strings.Index(u.Path, "/")
if ix > 0 {
u.Scheme = u.Path[:ix]
u.Path = u.Path[ix:]
}
}
return u
}
|
go
|
func urlParse(name string) *url.URL {
var info os.FileInfo
u, err := url.Parse(name)
if err == nil && u.Scheme == "" {
info, err = os.Stat(u.Path)
if err == nil && info.IsDir() {
u.Scheme = ArchiveScheme // special case for IsDir()
return u
}
}
u, err = url.Parse(strings.TrimPrefix(name, "/")) // must appear to be an absolute path or hgfs errors
if err != nil {
u = &url.URL{Path: name}
}
if u.Scheme == "" {
ix := strings.Index(u.Path, "/")
if ix > 0 {
u.Scheme = u.Path[:ix]
u.Path = u.Path[ix:]
}
}
return u
}
|
[
"func",
"urlParse",
"(",
"name",
"string",
")",
"*",
"url",
".",
"URL",
"{",
"var",
"info",
"os",
".",
"FileInfo",
"\n",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"name",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"u",
".",
"Scheme",
"==",
"\"\"",
"{",
"info",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"u",
".",
"Path",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"info",
".",
"IsDir",
"(",
")",
"{",
"u",
".",
"Scheme",
"=",
"ArchiveScheme",
"\n",
"return",
"u",
"\n",
"}",
"\n",
"}",
"\n",
"u",
",",
"err",
"=",
"url",
".",
"Parse",
"(",
"strings",
".",
"TrimPrefix",
"(",
"name",
",",
"\"/\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
"=",
"&",
"url",
".",
"URL",
"{",
"Path",
":",
"name",
"}",
"\n",
"}",
"\n",
"if",
"u",
".",
"Scheme",
"==",
"\"\"",
"{",
"ix",
":=",
"strings",
".",
"Index",
"(",
"u",
".",
"Path",
",",
"\"/\"",
")",
"\n",
"if",
"ix",
">",
"0",
"{",
"u",
".",
"Scheme",
"=",
"u",
".",
"Path",
"[",
":",
"ix",
"]",
"\n",
"u",
".",
"Path",
"=",
"u",
".",
"Path",
"[",
"ix",
":",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"u",
"\n",
"}"
] |
// urlParse attempts to convert the given name to a URL with scheme for use as FileHandler dispatch.
|
[
"urlParse",
"attempts",
"to",
"convert",
"the",
"given",
"name",
"to",
"a",
"URL",
"with",
"scheme",
"for",
"use",
"as",
"FileHandler",
"dispatch",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L142-L168
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
OpenFile
|
func (s *Server) OpenFile(name string, mode int32) (File, error) {
u := urlParse(name)
if h, ok := s.schemes[u.Scheme]; ok {
f, serr := h.Open(u, mode)
if serr != os.ErrNotExist {
return f, serr
}
}
switch mode {
case OpenModeReadOnly:
return os.Open(filepath.Clean(name))
case OpenModeWriteOnly:
flag := os.O_WRONLY | os.O_CREATE | os.O_TRUNC
return os.OpenFile(name, flag, 0600)
default:
return nil, &Status{
Err: fmt.Errorf("open mode(%d) not supported for file %q", mode, name),
Code: StatusAccessDenied,
}
}
}
|
go
|
func (s *Server) OpenFile(name string, mode int32) (File, error) {
u := urlParse(name)
if h, ok := s.schemes[u.Scheme]; ok {
f, serr := h.Open(u, mode)
if serr != os.ErrNotExist {
return f, serr
}
}
switch mode {
case OpenModeReadOnly:
return os.Open(filepath.Clean(name))
case OpenModeWriteOnly:
flag := os.O_WRONLY | os.O_CREATE | os.O_TRUNC
return os.OpenFile(name, flag, 0600)
default:
return nil, &Status{
Err: fmt.Errorf("open mode(%d) not supported for file %q", mode, name),
Code: StatusAccessDenied,
}
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"OpenFile",
"(",
"name",
"string",
",",
"mode",
"int32",
")",
"(",
"File",
",",
"error",
")",
"{",
"u",
":=",
"urlParse",
"(",
"name",
")",
"\n",
"if",
"h",
",",
"ok",
":=",
"s",
".",
"schemes",
"[",
"u",
".",
"Scheme",
"]",
";",
"ok",
"{",
"f",
",",
"serr",
":=",
"h",
".",
"Open",
"(",
"u",
",",
"mode",
")",
"\n",
"if",
"serr",
"!=",
"os",
".",
"ErrNotExist",
"{",
"return",
"f",
",",
"serr",
"\n",
"}",
"\n",
"}",
"\n",
"switch",
"mode",
"{",
"case",
"OpenModeReadOnly",
":",
"return",
"os",
".",
"Open",
"(",
"filepath",
".",
"Clean",
"(",
"name",
")",
")",
"\n",
"case",
"OpenModeWriteOnly",
":",
"flag",
":=",
"os",
".",
"O_WRONLY",
"|",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_TRUNC",
"\n",
"return",
"os",
".",
"OpenFile",
"(",
"name",
",",
"flag",
",",
"0600",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"&",
"Status",
"{",
"Err",
":",
"fmt",
".",
"Errorf",
"(",
"\"open mode(%d) not supported for file %q\"",
",",
"mode",
",",
"name",
")",
",",
"Code",
":",
"StatusAccessDenied",
",",
"}",
"\n",
"}",
"\n",
"}"
] |
// OpenFile selects the File implementation based on file type and mode.
|
[
"OpenFile",
"selects",
"the",
"File",
"implementation",
"based",
"on",
"file",
"type",
"and",
"mode",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L171-L193
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
CreateSessionV4
|
func (s *Server) CreateSessionV4(p *Packet) (interface{}, error) {
const SessionMaxPacketSizeValid = 0x1
req := new(RequestCreateSessionV4)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
res := &ReplyCreateSessionV4{
SessionID: uint64(rand.Int63()),
NumCapabilities: uint32(len(s.Capabilities)),
MaxPacketSize: LargePacketMax,
Flags: SessionMaxPacketSizeValid,
Capabilities: s.Capabilities,
}
s.mu.Lock()
defer s.mu.Unlock()
if len(s.sessions) > maxSessions {
return nil, &Status{Code: StatusTooManySessions}
}
s.sessions[res.SessionID] = newSession()
return res, nil
}
|
go
|
func (s *Server) CreateSessionV4(p *Packet) (interface{}, error) {
const SessionMaxPacketSizeValid = 0x1
req := new(RequestCreateSessionV4)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
res := &ReplyCreateSessionV4{
SessionID: uint64(rand.Int63()),
NumCapabilities: uint32(len(s.Capabilities)),
MaxPacketSize: LargePacketMax,
Flags: SessionMaxPacketSizeValid,
Capabilities: s.Capabilities,
}
s.mu.Lock()
defer s.mu.Unlock()
if len(s.sessions) > maxSessions {
return nil, &Status{Code: StatusTooManySessions}
}
s.sessions[res.SessionID] = newSession()
return res, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"CreateSessionV4",
"(",
"p",
"*",
"Packet",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"const",
"SessionMaxPacketSizeValid",
"=",
"0x1",
"\n",
"req",
":=",
"new",
"(",
"RequestCreateSessionV4",
")",
"\n",
"err",
":=",
"UnmarshalBinary",
"(",
"p",
".",
"Payload",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
":=",
"&",
"ReplyCreateSessionV4",
"{",
"SessionID",
":",
"uint64",
"(",
"rand",
".",
"Int63",
"(",
")",
")",
",",
"NumCapabilities",
":",
"uint32",
"(",
"len",
"(",
"s",
".",
"Capabilities",
")",
")",
",",
"MaxPacketSize",
":",
"LargePacketMax",
",",
"Flags",
":",
"SessionMaxPacketSizeValid",
",",
"Capabilities",
":",
"s",
".",
"Capabilities",
",",
"}",
"\n",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"len",
"(",
"s",
".",
"sessions",
")",
">",
"maxSessions",
"{",
"return",
"nil",
",",
"&",
"Status",
"{",
"Code",
":",
"StatusTooManySessions",
"}",
"\n",
"}",
"\n",
"s",
".",
"sessions",
"[",
"res",
".",
"SessionID",
"]",
"=",
"newSession",
"(",
")",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// CreateSessionV4 handls OpCreateSessionV4 requests
|
[
"CreateSessionV4",
"handls",
"OpCreateSessionV4",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L271-L297
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
DestroySessionV4
|
func (s *Server) DestroySessionV4(p *Packet) (interface{}, error) {
if s.removeSession(p.SessionID) {
return &ReplyDestroySessionV4{}, nil
}
return nil, &Status{Code: StatusStaleSession}
}
|
go
|
func (s *Server) DestroySessionV4(p *Packet) (interface{}, error) {
if s.removeSession(p.SessionID) {
return &ReplyDestroySessionV4{}, nil
}
return nil, &Status{Code: StatusStaleSession}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"DestroySessionV4",
"(",
"p",
"*",
"Packet",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"s",
".",
"removeSession",
"(",
"p",
".",
"SessionID",
")",
"{",
"return",
"&",
"ReplyDestroySessionV4",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"&",
"Status",
"{",
"Code",
":",
"StatusStaleSession",
"}",
"\n",
"}"
] |
// DestroySessionV4 handls OpDestroySessionV4 requests
|
[
"DestroySessionV4",
"handls",
"OpDestroySessionV4",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L300-L306
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
Stat
|
func (a *AttrV2) Stat(info os.FileInfo) {
switch {
case info.IsDir():
a.Type = FileTypeDirectory
case info.Mode()&os.ModeSymlink == os.ModeSymlink:
a.Type = FileTypeSymlink
default:
a.Type = FileTypeRegular
}
a.Size = uint64(info.Size())
a.Mask = AttrValidType | AttrValidSize
a.sysStat(info)
}
|
go
|
func (a *AttrV2) Stat(info os.FileInfo) {
switch {
case info.IsDir():
a.Type = FileTypeDirectory
case info.Mode()&os.ModeSymlink == os.ModeSymlink:
a.Type = FileTypeSymlink
default:
a.Type = FileTypeRegular
}
a.Size = uint64(info.Size())
a.Mask = AttrValidType | AttrValidSize
a.sysStat(info)
}
|
[
"func",
"(",
"a",
"*",
"AttrV2",
")",
"Stat",
"(",
"info",
"os",
".",
"FileInfo",
")",
"{",
"switch",
"{",
"case",
"info",
".",
"IsDir",
"(",
")",
":",
"a",
".",
"Type",
"=",
"FileTypeDirectory",
"\n",
"case",
"info",
".",
"Mode",
"(",
")",
"&",
"os",
".",
"ModeSymlink",
"==",
"os",
".",
"ModeSymlink",
":",
"a",
".",
"Type",
"=",
"FileTypeSymlink",
"\n",
"default",
":",
"a",
".",
"Type",
"=",
"FileTypeRegular",
"\n",
"}",
"\n",
"a",
".",
"Size",
"=",
"uint64",
"(",
"info",
".",
"Size",
"(",
")",
")",
"\n",
"a",
".",
"Mask",
"=",
"AttrValidType",
"|",
"AttrValidSize",
"\n",
"a",
".",
"sysStat",
"(",
"info",
")",
"\n",
"}"
] |
// Stat maps os.FileInfo to AttrV2
|
[
"Stat",
"maps",
"os",
".",
"FileInfo",
"to",
"AttrV2"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L309-L324
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
GetattrV2
|
func (s *Server) GetattrV2(p *Packet) (interface{}, error) {
res := &ReplyGetattrV2{}
req := new(RequestGetattrV2)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
name := req.FileName.Path()
info, err := s.Stat(name)
if err != nil {
return nil, err
}
res.Attr.Stat(info)
return res, nil
}
|
go
|
func (s *Server) GetattrV2(p *Packet) (interface{}, error) {
res := &ReplyGetattrV2{}
req := new(RequestGetattrV2)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
name := req.FileName.Path()
info, err := s.Stat(name)
if err != nil {
return nil, err
}
res.Attr.Stat(info)
return res, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"GetattrV2",
"(",
"p",
"*",
"Packet",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"res",
":=",
"&",
"ReplyGetattrV2",
"{",
"}",
"\n",
"req",
":=",
"new",
"(",
"RequestGetattrV2",
")",
"\n",
"err",
":=",
"UnmarshalBinary",
"(",
"p",
".",
"Payload",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"name",
":=",
"req",
".",
"FileName",
".",
"Path",
"(",
")",
"\n",
"info",
",",
"err",
":=",
"s",
".",
"Stat",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
".",
"Attr",
".",
"Stat",
"(",
"info",
")",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// GetattrV2 handles OpGetattrV2 requests
|
[
"GetattrV2",
"handles",
"OpGetattrV2",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L327-L345
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
SetattrV2
|
func (s *Server) SetattrV2(p *Packet) (interface{}, error) {
res := &ReplySetattrV2{}
req := new(RequestSetattrV2)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
name := req.FileName.Path()
_, err = os.Stat(name)
if err != nil && os.IsNotExist(err) {
// assuming this is a virtual file
return res, nil
}
uid := -1
if req.Attr.Mask&AttrValidUserID == AttrValidUserID {
uid = int(req.Attr.UserID)
}
gid := -1
if req.Attr.Mask&AttrValidGroupID == AttrValidGroupID {
gid = int(req.Attr.GroupID)
}
err = s.chown(name, uid, gid)
if err != nil {
return nil, err
}
var perm os.FileMode
if req.Attr.Mask&AttrValidOwnerPerms == AttrValidOwnerPerms {
perm |= os.FileMode(req.Attr.OwnerPerms) << 6
}
if req.Attr.Mask&AttrValidGroupPerms == AttrValidGroupPerms {
perm |= os.FileMode(req.Attr.GroupPerms) << 3
}
if req.Attr.Mask&AttrValidOtherPerms == AttrValidOtherPerms {
perm |= os.FileMode(req.Attr.OtherPerms)
}
if perm != 0 {
err = s.chmod(name, perm)
if err != nil {
return nil, err
}
}
return res, nil
}
|
go
|
func (s *Server) SetattrV2(p *Packet) (interface{}, error) {
res := &ReplySetattrV2{}
req := new(RequestSetattrV2)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
name := req.FileName.Path()
_, err = os.Stat(name)
if err != nil && os.IsNotExist(err) {
// assuming this is a virtual file
return res, nil
}
uid := -1
if req.Attr.Mask&AttrValidUserID == AttrValidUserID {
uid = int(req.Attr.UserID)
}
gid := -1
if req.Attr.Mask&AttrValidGroupID == AttrValidGroupID {
gid = int(req.Attr.GroupID)
}
err = s.chown(name, uid, gid)
if err != nil {
return nil, err
}
var perm os.FileMode
if req.Attr.Mask&AttrValidOwnerPerms == AttrValidOwnerPerms {
perm |= os.FileMode(req.Attr.OwnerPerms) << 6
}
if req.Attr.Mask&AttrValidGroupPerms == AttrValidGroupPerms {
perm |= os.FileMode(req.Attr.GroupPerms) << 3
}
if req.Attr.Mask&AttrValidOtherPerms == AttrValidOtherPerms {
perm |= os.FileMode(req.Attr.OtherPerms)
}
if perm != 0 {
err = s.chmod(name, perm)
if err != nil {
return nil, err
}
}
return res, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"SetattrV2",
"(",
"p",
"*",
"Packet",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"res",
":=",
"&",
"ReplySetattrV2",
"{",
"}",
"\n",
"req",
":=",
"new",
"(",
"RequestSetattrV2",
")",
"\n",
"err",
":=",
"UnmarshalBinary",
"(",
"p",
".",
"Payload",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"name",
":=",
"req",
".",
"FileName",
".",
"Path",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"res",
",",
"nil",
"\n",
"}",
"\n",
"uid",
":=",
"-",
"1",
"\n",
"if",
"req",
".",
"Attr",
".",
"Mask",
"&",
"AttrValidUserID",
"==",
"AttrValidUserID",
"{",
"uid",
"=",
"int",
"(",
"req",
".",
"Attr",
".",
"UserID",
")",
"\n",
"}",
"\n",
"gid",
":=",
"-",
"1",
"\n",
"if",
"req",
".",
"Attr",
".",
"Mask",
"&",
"AttrValidGroupID",
"==",
"AttrValidGroupID",
"{",
"gid",
"=",
"int",
"(",
"req",
".",
"Attr",
".",
"GroupID",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"chown",
"(",
"name",
",",
"uid",
",",
"gid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"perm",
"os",
".",
"FileMode",
"\n",
"if",
"req",
".",
"Attr",
".",
"Mask",
"&",
"AttrValidOwnerPerms",
"==",
"AttrValidOwnerPerms",
"{",
"perm",
"|=",
"os",
".",
"FileMode",
"(",
"req",
".",
"Attr",
".",
"OwnerPerms",
")",
"<<",
"6",
"\n",
"}",
"\n",
"if",
"req",
".",
"Attr",
".",
"Mask",
"&",
"AttrValidGroupPerms",
"==",
"AttrValidGroupPerms",
"{",
"perm",
"|=",
"os",
".",
"FileMode",
"(",
"req",
".",
"Attr",
".",
"GroupPerms",
")",
"<<",
"3",
"\n",
"}",
"\n",
"if",
"req",
".",
"Attr",
".",
"Mask",
"&",
"AttrValidOtherPerms",
"==",
"AttrValidOtherPerms",
"{",
"perm",
"|=",
"os",
".",
"FileMode",
"(",
"req",
".",
"Attr",
".",
"OtherPerms",
")",
"\n",
"}",
"\n",
"if",
"perm",
"!=",
"0",
"{",
"err",
"=",
"s",
".",
"chmod",
"(",
"name",
",",
"perm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// SetattrV2 handles OpSetattrV2 requests
|
[
"SetattrV2",
"handles",
"OpSetattrV2",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L348-L402
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
Open
|
func (s *Server) Open(p *Packet) (interface{}, error) {
req := new(RequestOpen)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
session, err := s.getSession(p)
if err != nil {
return nil, err
}
name := req.FileName.Path()
mode := req.OpenMode
if mode != OpenModeReadOnly {
return nil, &Status{
Err: fmt.Errorf("open mode(%d) not supported for file %q", mode, name),
Code: StatusAccessDenied,
}
}
file, err := s.OpenFile(name, mode)
if err != nil {
return nil, err
}
res := &ReplyOpen{
Handle: s.newHandle(),
}
session.mu.Lock()
session.files[res.Handle] = file
session.mu.Unlock()
return res, nil
}
|
go
|
func (s *Server) Open(p *Packet) (interface{}, error) {
req := new(RequestOpen)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
session, err := s.getSession(p)
if err != nil {
return nil, err
}
name := req.FileName.Path()
mode := req.OpenMode
if mode != OpenModeReadOnly {
return nil, &Status{
Err: fmt.Errorf("open mode(%d) not supported for file %q", mode, name),
Code: StatusAccessDenied,
}
}
file, err := s.OpenFile(name, mode)
if err != nil {
return nil, err
}
res := &ReplyOpen{
Handle: s.newHandle(),
}
session.mu.Lock()
session.files[res.Handle] = file
session.mu.Unlock()
return res, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"Open",
"(",
"p",
"*",
"Packet",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"req",
":=",
"new",
"(",
"RequestOpen",
")",
"\n",
"err",
":=",
"UnmarshalBinary",
"(",
"p",
".",
"Payload",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"session",
",",
"err",
":=",
"s",
".",
"getSession",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"name",
":=",
"req",
".",
"FileName",
".",
"Path",
"(",
")",
"\n",
"mode",
":=",
"req",
".",
"OpenMode",
"\n",
"if",
"mode",
"!=",
"OpenModeReadOnly",
"{",
"return",
"nil",
",",
"&",
"Status",
"{",
"Err",
":",
"fmt",
".",
"Errorf",
"(",
"\"open mode(%d) not supported for file %q\"",
",",
"mode",
",",
"name",
")",
",",
"Code",
":",
"StatusAccessDenied",
",",
"}",
"\n",
"}",
"\n",
"file",
",",
"err",
":=",
"s",
".",
"OpenFile",
"(",
"name",
",",
"mode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
":=",
"&",
"ReplyOpen",
"{",
"Handle",
":",
"s",
".",
"newHandle",
"(",
")",
",",
"}",
"\n",
"session",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"session",
".",
"files",
"[",
"res",
".",
"Handle",
"]",
"=",
"file",
"\n",
"session",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// Open handles OpOpen requests
|
[
"Open",
"handles",
"OpOpen",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L409-L445
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
Close
|
func (s *Server) Close(p *Packet) (interface{}, error) {
req := new(RequestClose)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
session, err := s.getSession(p)
if err != nil {
return nil, err
}
session.mu.Lock()
file, ok := session.files[req.Handle]
if ok {
delete(session.files, req.Handle)
}
session.mu.Unlock()
if ok {
err = file.Close()
} else {
return nil, &Status{Code: StatusInvalidHandle}
}
return &ReplyClose{}, err
}
|
go
|
func (s *Server) Close(p *Packet) (interface{}, error) {
req := new(RequestClose)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
session, err := s.getSession(p)
if err != nil {
return nil, err
}
session.mu.Lock()
file, ok := session.files[req.Handle]
if ok {
delete(session.files, req.Handle)
}
session.mu.Unlock()
if ok {
err = file.Close()
} else {
return nil, &Status{Code: StatusInvalidHandle}
}
return &ReplyClose{}, err
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"Close",
"(",
"p",
"*",
"Packet",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"req",
":=",
"new",
"(",
"RequestClose",
")",
"\n",
"err",
":=",
"UnmarshalBinary",
"(",
"p",
".",
"Payload",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"session",
",",
"err",
":=",
"s",
".",
"getSession",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"session",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"file",
",",
"ok",
":=",
"session",
".",
"files",
"[",
"req",
".",
"Handle",
"]",
"\n",
"if",
"ok",
"{",
"delete",
"(",
"session",
".",
"files",
",",
"req",
".",
"Handle",
")",
"\n",
"}",
"\n",
"session",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"ok",
"{",
"err",
"=",
"file",
".",
"Close",
"(",
")",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"&",
"Status",
"{",
"Code",
":",
"StatusInvalidHandle",
"}",
"\n",
"}",
"\n",
"return",
"&",
"ReplyClose",
"{",
"}",
",",
"err",
"\n",
"}"
] |
// Close handles OpClose requests
|
[
"Close",
"handles",
"OpClose",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L448-L474
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
OpenV3
|
func (s *Server) OpenV3(p *Packet) (interface{}, error) {
req := new(RequestOpenV3)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
session, err := s.getSession(p)
if err != nil {
return nil, err
}
name := req.FileName.Path()
if req.DesiredLock != LockNone {
return nil, &Status{
Err: fmt.Errorf("open lock type=%d not supported for file %q", req.DesiredLock, name),
Code: StatusOperationNotSupported,
}
}
file, err := s.OpenFile(name, req.OpenMode)
if err != nil {
return nil, err
}
res := &ReplyOpenV3{
Handle: s.newHandle(),
}
session.mu.Lock()
session.files[res.Handle] = file
session.mu.Unlock()
return res, nil
}
|
go
|
func (s *Server) OpenV3(p *Packet) (interface{}, error) {
req := new(RequestOpenV3)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
session, err := s.getSession(p)
if err != nil {
return nil, err
}
name := req.FileName.Path()
if req.DesiredLock != LockNone {
return nil, &Status{
Err: fmt.Errorf("open lock type=%d not supported for file %q", req.DesiredLock, name),
Code: StatusOperationNotSupported,
}
}
file, err := s.OpenFile(name, req.OpenMode)
if err != nil {
return nil, err
}
res := &ReplyOpenV3{
Handle: s.newHandle(),
}
session.mu.Lock()
session.files[res.Handle] = file
session.mu.Unlock()
return res, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"OpenV3",
"(",
"p",
"*",
"Packet",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"req",
":=",
"new",
"(",
"RequestOpenV3",
")",
"\n",
"err",
":=",
"UnmarshalBinary",
"(",
"p",
".",
"Payload",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"session",
",",
"err",
":=",
"s",
".",
"getSession",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"name",
":=",
"req",
".",
"FileName",
".",
"Path",
"(",
")",
"\n",
"if",
"req",
".",
"DesiredLock",
"!=",
"LockNone",
"{",
"return",
"nil",
",",
"&",
"Status",
"{",
"Err",
":",
"fmt",
".",
"Errorf",
"(",
"\"open lock type=%d not supported for file %q\"",
",",
"req",
".",
"DesiredLock",
",",
"name",
")",
",",
"Code",
":",
"StatusOperationNotSupported",
",",
"}",
"\n",
"}",
"\n",
"file",
",",
"err",
":=",
"s",
".",
"OpenFile",
"(",
"name",
",",
"req",
".",
"OpenMode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
":=",
"&",
"ReplyOpenV3",
"{",
"Handle",
":",
"s",
".",
"newHandle",
"(",
")",
",",
"}",
"\n",
"session",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"session",
".",
"files",
"[",
"res",
".",
"Handle",
"]",
"=",
"file",
"\n",
"session",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// OpenV3 handles OpOpenV3 requests
|
[
"OpenV3",
"handles",
"OpOpenV3",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L477-L512
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
ReadV3
|
func (s *Server) ReadV3(p *Packet) (interface{}, error) {
req := new(RequestReadV3)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
session, err := s.getSession(p)
if err != nil {
return nil, err
}
session.mu.Lock()
file, ok := session.files[req.Handle]
session.mu.Unlock()
if !ok {
return nil, &Status{Code: StatusInvalidHandle}
}
buf := make([]byte, req.RequiredSize)
// Use ReadFull as Read() of an archive io.Pipe may return much smaller chunks,
// such as when we've read a tar header.
n, err := io.ReadFull(file, buf)
if err != nil && n == 0 {
if err != io.EOF {
return nil, err
}
}
res := &ReplyReadV3{
ActualSize: uint32(n),
Payload: buf[:n],
}
return res, nil
}
|
go
|
func (s *Server) ReadV3(p *Packet) (interface{}, error) {
req := new(RequestReadV3)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
session, err := s.getSession(p)
if err != nil {
return nil, err
}
session.mu.Lock()
file, ok := session.files[req.Handle]
session.mu.Unlock()
if !ok {
return nil, &Status{Code: StatusInvalidHandle}
}
buf := make([]byte, req.RequiredSize)
// Use ReadFull as Read() of an archive io.Pipe may return much smaller chunks,
// such as when we've read a tar header.
n, err := io.ReadFull(file, buf)
if err != nil && n == 0 {
if err != io.EOF {
return nil, err
}
}
res := &ReplyReadV3{
ActualSize: uint32(n),
Payload: buf[:n],
}
return res, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"ReadV3",
"(",
"p",
"*",
"Packet",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"req",
":=",
"new",
"(",
"RequestReadV3",
")",
"\n",
"err",
":=",
"UnmarshalBinary",
"(",
"p",
".",
"Payload",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"session",
",",
"err",
":=",
"s",
".",
"getSession",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"session",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"file",
",",
"ok",
":=",
"session",
".",
"files",
"[",
"req",
".",
"Handle",
"]",
"\n",
"session",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"&",
"Status",
"{",
"Code",
":",
"StatusInvalidHandle",
"}",
"\n",
"}",
"\n",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"req",
".",
"RequiredSize",
")",
"\n",
"n",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"file",
",",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"n",
"==",
"0",
"{",
"if",
"err",
"!=",
"io",
".",
"EOF",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"res",
":=",
"&",
"ReplyReadV3",
"{",
"ActualSize",
":",
"uint32",
"(",
"n",
")",
",",
"Payload",
":",
"buf",
"[",
":",
"n",
"]",
",",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// ReadV3 handles OpReadV3 requests
|
[
"ReadV3",
"handles",
"OpReadV3",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L515-L552
|
train
|
vmware/govmomi
|
toolbox/hgfs/server.go
|
WriteV3
|
func (s *Server) WriteV3(p *Packet) (interface{}, error) {
req := new(RequestWriteV3)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
session, err := s.getSession(p)
if err != nil {
return nil, err
}
session.mu.Lock()
file, ok := session.files[req.Handle]
session.mu.Unlock()
if !ok {
return nil, &Status{Code: StatusInvalidHandle}
}
n, err := file.Write(req.Payload)
if err != nil {
return nil, err
}
res := &ReplyWriteV3{
ActualSize: uint32(n),
}
return res, nil
}
|
go
|
func (s *Server) WriteV3(p *Packet) (interface{}, error) {
req := new(RequestWriteV3)
err := UnmarshalBinary(p.Payload, req)
if err != nil {
return nil, err
}
session, err := s.getSession(p)
if err != nil {
return nil, err
}
session.mu.Lock()
file, ok := session.files[req.Handle]
session.mu.Unlock()
if !ok {
return nil, &Status{Code: StatusInvalidHandle}
}
n, err := file.Write(req.Payload)
if err != nil {
return nil, err
}
res := &ReplyWriteV3{
ActualSize: uint32(n),
}
return res, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"WriteV3",
"(",
"p",
"*",
"Packet",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"req",
":=",
"new",
"(",
"RequestWriteV3",
")",
"\n",
"err",
":=",
"UnmarshalBinary",
"(",
"p",
".",
"Payload",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"session",
",",
"err",
":=",
"s",
".",
"getSession",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"session",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"file",
",",
"ok",
":=",
"session",
".",
"files",
"[",
"req",
".",
"Handle",
"]",
"\n",
"session",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"&",
"Status",
"{",
"Code",
":",
"StatusInvalidHandle",
"}",
"\n",
"}",
"\n",
"n",
",",
"err",
":=",
"file",
".",
"Write",
"(",
"req",
".",
"Payload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
":=",
"&",
"ReplyWriteV3",
"{",
"ActualSize",
":",
"uint32",
"(",
"n",
")",
",",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// WriteV3 handles OpWriteV3 requests
|
[
"WriteV3",
"handles",
"OpWriteV3",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/hgfs/server.go#L555-L585
|
train
|
vmware/govmomi
|
simulator/internal/server.go
|
NewServer
|
func NewServer(handler http.Handler) *Server {
ts := NewUnstartedServer(handler, "")
ts.Start()
return ts
}
|
go
|
func NewServer(handler http.Handler) *Server {
ts := NewUnstartedServer(handler, "")
ts.Start()
return ts
}
|
[
"func",
"NewServer",
"(",
"handler",
"http",
".",
"Handler",
")",
"*",
"Server",
"{",
"ts",
":=",
"NewUnstartedServer",
"(",
"handler",
",",
"\"\"",
")",
"\n",
"ts",
".",
"Start",
"(",
")",
"\n",
"return",
"ts",
"\n",
"}"
] |
// NewServer starts and returns a new Server.
// The caller should call Close when finished, to shut it down.
|
[
"NewServer",
"starts",
"and",
"returns",
"a",
"new",
"Server",
".",
"The",
"caller",
"should",
"call",
"Close",
"when",
"finished",
"to",
"shut",
"it",
"down",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/internal/server.go#L71-L75
|
train
|
vmware/govmomi
|
simulator/internal/server.go
|
NewUnstartedServer
|
func NewUnstartedServer(handler http.Handler, serve string) *Server {
return &Server{
Listener: newLocalListener(serve),
Config: &http.Server{Handler: handler},
}
}
|
go
|
func NewUnstartedServer(handler http.Handler, serve string) *Server {
return &Server{
Listener: newLocalListener(serve),
Config: &http.Server{Handler: handler},
}
}
|
[
"func",
"NewUnstartedServer",
"(",
"handler",
"http",
".",
"Handler",
",",
"serve",
"string",
")",
"*",
"Server",
"{",
"return",
"&",
"Server",
"{",
"Listener",
":",
"newLocalListener",
"(",
"serve",
")",
",",
"Config",
":",
"&",
"http",
".",
"Server",
"{",
"Handler",
":",
"handler",
"}",
",",
"}",
"\n",
"}"
] |
// NewUnstartedServer returns a new Server but doesn't start it.
//
// After changing its configuration, the caller should call Start or
// StartTLS.
//
// The caller should call Close when finished, to shut it down.
// serve allows the server's listen address to be specified.
|
[
"NewUnstartedServer",
"returns",
"a",
"new",
"Server",
"but",
"doesn",
"t",
"start",
"it",
".",
"After",
"changing",
"its",
"configuration",
"the",
"caller",
"should",
"call",
"Start",
"or",
"StartTLS",
".",
"The",
"caller",
"should",
"call",
"Close",
"when",
"finished",
"to",
"shut",
"it",
"down",
".",
"serve",
"allows",
"the",
"server",
"s",
"listen",
"address",
"to",
"be",
"specified",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/internal/server.go#L84-L89
|
train
|
vmware/govmomi
|
simulator/internal/server.go
|
Start
|
func (s *Server) Start() {
if s.URL != "" {
panic("Server already started")
}
if s.client == nil {
s.client = &http.Client{Transport: &http.Transport{}}
}
s.URL = "http://" + s.Listener.Addr().String()
s.wrap()
s.goServe()
}
|
go
|
func (s *Server) Start() {
if s.URL != "" {
panic("Server already started")
}
if s.client == nil {
s.client = &http.Client{Transport: &http.Transport{}}
}
s.URL = "http://" + s.Listener.Addr().String()
s.wrap()
s.goServe()
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"Start",
"(",
")",
"{",
"if",
"s",
".",
"URL",
"!=",
"\"\"",
"{",
"panic",
"(",
"\"Server already started\"",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"client",
"==",
"nil",
"{",
"s",
".",
"client",
"=",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"&",
"http",
".",
"Transport",
"{",
"}",
"}",
"\n",
"}",
"\n",
"s",
".",
"URL",
"=",
"\"http://\"",
"+",
"s",
".",
"Listener",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
"\n",
"s",
".",
"wrap",
"(",
")",
"\n",
"s",
".",
"goServe",
"(",
")",
"\n",
"}"
] |
// Start starts a server from NewUnstartedServer.
|
[
"Start",
"starts",
"a",
"server",
"from",
"NewUnstartedServer",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/internal/server.go#L92-L102
|
train
|
vmware/govmomi
|
simulator/internal/server.go
|
StartTLS
|
func (s *Server) StartTLS() {
if s.URL != "" {
panic("Server already started")
}
if s.client == nil {
s.client = &http.Client{Transport: &http.Transport{}}
}
cert, err := tls.X509KeyPair(LocalhostCert, LocalhostKey)
if err != nil {
panic(fmt.Sprintf("httptest: NewTLSServer: %v", err))
}
existingConfig := s.TLS
if existingConfig != nil {
s.TLS = existingConfig.Clone()
} else {
s.TLS = new(tls.Config)
}
if s.TLS.NextProtos == nil {
s.TLS.NextProtos = []string{"http/1.1"}
}
if len(s.TLS.Certificates) == 0 {
s.TLS.Certificates = []tls.Certificate{cert}
}
s.certificate, err = x509.ParseCertificate(s.TLS.Certificates[0].Certificate[0])
if err != nil {
panic(fmt.Sprintf("httptest: NewTLSServer: %v", err))
}
certpool := x509.NewCertPool()
certpool.AddCert(s.certificate)
s.client.Transport = &http.Transport{
TLSClientConfig: &tls.Config{
RootCAs: certpool,
},
}
s.Listener = tls.NewListener(s.Listener, s.TLS)
s.URL = "https://" + s.Listener.Addr().String()
s.wrap()
s.goServe()
}
|
go
|
func (s *Server) StartTLS() {
if s.URL != "" {
panic("Server already started")
}
if s.client == nil {
s.client = &http.Client{Transport: &http.Transport{}}
}
cert, err := tls.X509KeyPair(LocalhostCert, LocalhostKey)
if err != nil {
panic(fmt.Sprintf("httptest: NewTLSServer: %v", err))
}
existingConfig := s.TLS
if existingConfig != nil {
s.TLS = existingConfig.Clone()
} else {
s.TLS = new(tls.Config)
}
if s.TLS.NextProtos == nil {
s.TLS.NextProtos = []string{"http/1.1"}
}
if len(s.TLS.Certificates) == 0 {
s.TLS.Certificates = []tls.Certificate{cert}
}
s.certificate, err = x509.ParseCertificate(s.TLS.Certificates[0].Certificate[0])
if err != nil {
panic(fmt.Sprintf("httptest: NewTLSServer: %v", err))
}
certpool := x509.NewCertPool()
certpool.AddCert(s.certificate)
s.client.Transport = &http.Transport{
TLSClientConfig: &tls.Config{
RootCAs: certpool,
},
}
s.Listener = tls.NewListener(s.Listener, s.TLS)
s.URL = "https://" + s.Listener.Addr().String()
s.wrap()
s.goServe()
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"StartTLS",
"(",
")",
"{",
"if",
"s",
".",
"URL",
"!=",
"\"\"",
"{",
"panic",
"(",
"\"Server already started\"",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"client",
"==",
"nil",
"{",
"s",
".",
"client",
"=",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"&",
"http",
".",
"Transport",
"{",
"}",
"}",
"\n",
"}",
"\n",
"cert",
",",
"err",
":=",
"tls",
".",
"X509KeyPair",
"(",
"LocalhostCert",
",",
"LocalhostKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"httptest: NewTLSServer: %v\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"existingConfig",
":=",
"s",
".",
"TLS",
"\n",
"if",
"existingConfig",
"!=",
"nil",
"{",
"s",
".",
"TLS",
"=",
"existingConfig",
".",
"Clone",
"(",
")",
"\n",
"}",
"else",
"{",
"s",
".",
"TLS",
"=",
"new",
"(",
"tls",
".",
"Config",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"TLS",
".",
"NextProtos",
"==",
"nil",
"{",
"s",
".",
"TLS",
".",
"NextProtos",
"=",
"[",
"]",
"string",
"{",
"\"http/1.1\"",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"s",
".",
"TLS",
".",
"Certificates",
")",
"==",
"0",
"{",
"s",
".",
"TLS",
".",
"Certificates",
"=",
"[",
"]",
"tls",
".",
"Certificate",
"{",
"cert",
"}",
"\n",
"}",
"\n",
"s",
".",
"certificate",
",",
"err",
"=",
"x509",
".",
"ParseCertificate",
"(",
"s",
".",
"TLS",
".",
"Certificates",
"[",
"0",
"]",
".",
"Certificate",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"httptest: NewTLSServer: %v\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"certpool",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"certpool",
".",
"AddCert",
"(",
"s",
".",
"certificate",
")",
"\n",
"s",
".",
"client",
".",
"Transport",
"=",
"&",
"http",
".",
"Transport",
"{",
"TLSClientConfig",
":",
"&",
"tls",
".",
"Config",
"{",
"RootCAs",
":",
"certpool",
",",
"}",
",",
"}",
"\n",
"s",
".",
"Listener",
"=",
"tls",
".",
"NewListener",
"(",
"s",
".",
"Listener",
",",
"s",
".",
"TLS",
")",
"\n",
"s",
".",
"URL",
"=",
"\"https://\"",
"+",
"s",
".",
"Listener",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
"\n",
"s",
".",
"wrap",
"(",
")",
"\n",
"s",
".",
"goServe",
"(",
")",
"\n",
"}"
] |
// StartTLS starts TLS on a server from NewUnstartedServer.
|
[
"StartTLS",
"starts",
"TLS",
"on",
"a",
"server",
"from",
"NewUnstartedServer",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/internal/server.go#L105-L144
|
train
|
vmware/govmomi
|
simulator/internal/server.go
|
NewTLSServer
|
func NewTLSServer(handler http.Handler) *Server {
ts := NewUnstartedServer(handler, "")
ts.StartTLS()
return ts
}
|
go
|
func NewTLSServer(handler http.Handler) *Server {
ts := NewUnstartedServer(handler, "")
ts.StartTLS()
return ts
}
|
[
"func",
"NewTLSServer",
"(",
"handler",
"http",
".",
"Handler",
")",
"*",
"Server",
"{",
"ts",
":=",
"NewUnstartedServer",
"(",
"handler",
",",
"\"\"",
")",
"\n",
"ts",
".",
"StartTLS",
"(",
")",
"\n",
"return",
"ts",
"\n",
"}"
] |
// NewTLSServer starts and returns a new Server using TLS.
// The caller should call Close when finished, to shut it down.
|
[
"NewTLSServer",
"starts",
"and",
"returns",
"a",
"new",
"Server",
"using",
"TLS",
".",
"The",
"caller",
"should",
"call",
"Close",
"when",
"finished",
"to",
"shut",
"it",
"down",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/internal/server.go#L148-L152
|
train
|
vmware/govmomi
|
simulator/internal/server.go
|
CloseClientConnections
|
func (s *Server) CloseClientConnections() {
s.mu.Lock()
nconn := len(s.conns)
ch := make(chan struct{}, nconn)
for c := range s.conns {
go s.closeConnChan(c, ch)
}
s.mu.Unlock()
// Wait for outstanding closes to finish.
//
// Out of paranoia for making a late change in Go 1.6, we
// bound how long this can wait, since golang.org/issue/14291
// isn't fully understood yet. At least this should only be used
// in tests.
timer := time.NewTimer(5 * time.Second)
defer timer.Stop()
for i := 0; i < nconn; i++ {
select {
case <-ch:
case <-timer.C:
// Too slow. Give up.
return
}
}
}
|
go
|
func (s *Server) CloseClientConnections() {
s.mu.Lock()
nconn := len(s.conns)
ch := make(chan struct{}, nconn)
for c := range s.conns {
go s.closeConnChan(c, ch)
}
s.mu.Unlock()
// Wait for outstanding closes to finish.
//
// Out of paranoia for making a late change in Go 1.6, we
// bound how long this can wait, since golang.org/issue/14291
// isn't fully understood yet. At least this should only be used
// in tests.
timer := time.NewTimer(5 * time.Second)
defer timer.Stop()
for i := 0; i < nconn; i++ {
select {
case <-ch:
case <-timer.C:
// Too slow. Give up.
return
}
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"CloseClientConnections",
"(",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"nconn",
":=",
"len",
"(",
"s",
".",
"conns",
")",
"\n",
"ch",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"nconn",
")",
"\n",
"for",
"c",
":=",
"range",
"s",
".",
"conns",
"{",
"go",
"s",
".",
"closeConnChan",
"(",
"c",
",",
"ch",
")",
"\n",
"}",
"\n",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"timer",
":=",
"time",
".",
"NewTimer",
"(",
"5",
"*",
"time",
".",
"Second",
")",
"\n",
"defer",
"timer",
".",
"Stop",
"(",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"nconn",
";",
"i",
"++",
"{",
"select",
"{",
"case",
"<-",
"ch",
":",
"case",
"<-",
"timer",
".",
"C",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// CloseClientConnections closes any open HTTP connections to the test Server.
|
[
"CloseClientConnections",
"closes",
"any",
"open",
"HTTP",
"connections",
"to",
"the",
"test",
"Server",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/internal/server.go#L224-L249
|
train
|
vmware/govmomi
|
simulator/internal/server.go
|
wrap
|
func (s *Server) wrap() {
oldHook := s.Config.ConnState
s.Config.ConnState = func(c net.Conn, cs http.ConnState) {
s.mu.Lock()
defer s.mu.Unlock()
switch cs {
case http.StateNew:
s.wg.Add(1)
if _, exists := s.conns[c]; exists {
panic("invalid state transition")
}
if s.conns == nil {
s.conns = make(map[net.Conn]http.ConnState)
}
s.conns[c] = cs
if s.closed {
// Probably just a socket-late-binding dial from
// the default transport that lost the race (and
// thus this connection is now idle and will
// never be used).
s.closeConn(c)
}
case http.StateActive:
if oldState, ok := s.conns[c]; ok {
if oldState != http.StateNew && oldState != http.StateIdle {
panic("invalid state transition")
}
s.conns[c] = cs
}
case http.StateIdle:
if oldState, ok := s.conns[c]; ok {
if oldState != http.StateActive {
panic("invalid state transition")
}
s.conns[c] = cs
}
if s.closed {
s.closeConn(c)
}
case http.StateHijacked, http.StateClosed:
s.forgetConn(c)
}
if oldHook != nil {
oldHook(c, cs)
}
}
}
|
go
|
func (s *Server) wrap() {
oldHook := s.Config.ConnState
s.Config.ConnState = func(c net.Conn, cs http.ConnState) {
s.mu.Lock()
defer s.mu.Unlock()
switch cs {
case http.StateNew:
s.wg.Add(1)
if _, exists := s.conns[c]; exists {
panic("invalid state transition")
}
if s.conns == nil {
s.conns = make(map[net.Conn]http.ConnState)
}
s.conns[c] = cs
if s.closed {
// Probably just a socket-late-binding dial from
// the default transport that lost the race (and
// thus this connection is now idle and will
// never be used).
s.closeConn(c)
}
case http.StateActive:
if oldState, ok := s.conns[c]; ok {
if oldState != http.StateNew && oldState != http.StateIdle {
panic("invalid state transition")
}
s.conns[c] = cs
}
case http.StateIdle:
if oldState, ok := s.conns[c]; ok {
if oldState != http.StateActive {
panic("invalid state transition")
}
s.conns[c] = cs
}
if s.closed {
s.closeConn(c)
}
case http.StateHijacked, http.StateClosed:
s.forgetConn(c)
}
if oldHook != nil {
oldHook(c, cs)
}
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"wrap",
"(",
")",
"{",
"oldHook",
":=",
"s",
".",
"Config",
".",
"ConnState",
"\n",
"s",
".",
"Config",
".",
"ConnState",
"=",
"func",
"(",
"c",
"net",
".",
"Conn",
",",
"cs",
"http",
".",
"ConnState",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"switch",
"cs",
"{",
"case",
"http",
".",
"StateNew",
":",
"s",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"if",
"_",
",",
"exists",
":=",
"s",
".",
"conns",
"[",
"c",
"]",
";",
"exists",
"{",
"panic",
"(",
"\"invalid state transition\"",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"conns",
"==",
"nil",
"{",
"s",
".",
"conns",
"=",
"make",
"(",
"map",
"[",
"net",
".",
"Conn",
"]",
"http",
".",
"ConnState",
")",
"\n",
"}",
"\n",
"s",
".",
"conns",
"[",
"c",
"]",
"=",
"cs",
"\n",
"if",
"s",
".",
"closed",
"{",
"s",
".",
"closeConn",
"(",
"c",
")",
"\n",
"}",
"\n",
"case",
"http",
".",
"StateActive",
":",
"if",
"oldState",
",",
"ok",
":=",
"s",
".",
"conns",
"[",
"c",
"]",
";",
"ok",
"{",
"if",
"oldState",
"!=",
"http",
".",
"StateNew",
"&&",
"oldState",
"!=",
"http",
".",
"StateIdle",
"{",
"panic",
"(",
"\"invalid state transition\"",
")",
"\n",
"}",
"\n",
"s",
".",
"conns",
"[",
"c",
"]",
"=",
"cs",
"\n",
"}",
"\n",
"case",
"http",
".",
"StateIdle",
":",
"if",
"oldState",
",",
"ok",
":=",
"s",
".",
"conns",
"[",
"c",
"]",
";",
"ok",
"{",
"if",
"oldState",
"!=",
"http",
".",
"StateActive",
"{",
"panic",
"(",
"\"invalid state transition\"",
")",
"\n",
"}",
"\n",
"s",
".",
"conns",
"[",
"c",
"]",
"=",
"cs",
"\n",
"}",
"\n",
"if",
"s",
".",
"closed",
"{",
"s",
".",
"closeConn",
"(",
"c",
")",
"\n",
"}",
"\n",
"case",
"http",
".",
"StateHijacked",
",",
"http",
".",
"StateClosed",
":",
"s",
".",
"forgetConn",
"(",
"c",
")",
"\n",
"}",
"\n",
"if",
"oldHook",
"!=",
"nil",
"{",
"oldHook",
"(",
"c",
",",
"cs",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// wrap installs the connection state-tracking hook to know which
// connections are idle.
|
[
"wrap",
"installs",
"the",
"connection",
"state",
"-",
"tracking",
"hook",
"to",
"know",
"which",
"connections",
"are",
"idle",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/internal/server.go#L274-L320
|
train
|
vmware/govmomi
|
simulator/internal/server.go
|
closeConnChan
|
func (s *Server) closeConnChan(c net.Conn, done chan<- struct{}) {
c.Close()
if done != nil {
done <- struct{}{}
}
}
|
go
|
func (s *Server) closeConnChan(c net.Conn, done chan<- struct{}) {
c.Close()
if done != nil {
done <- struct{}{}
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"closeConnChan",
"(",
"c",
"net",
".",
"Conn",
",",
"done",
"chan",
"<-",
"struct",
"{",
"}",
")",
"{",
"c",
".",
"Close",
"(",
")",
"\n",
"if",
"done",
"!=",
"nil",
"{",
"done",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}"
] |
// closeConnChan is like closeConn, but takes an optional channel to receive a value
// when the goroutine closing c is done.
|
[
"closeConnChan",
"is",
"like",
"closeConn",
"but",
"takes",
"an",
"optional",
"channel",
"to",
"receive",
"a",
"value",
"when",
"the",
"goroutine",
"closing",
"c",
"is",
"done",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/internal/server.go#L328-L333
|
train
|
vmware/govmomi
|
simulator/internal/server.go
|
forgetConn
|
func (s *Server) forgetConn(c net.Conn) {
if _, ok := s.conns[c]; ok {
delete(s.conns, c)
s.wg.Done()
}
}
|
go
|
func (s *Server) forgetConn(c net.Conn) {
if _, ok := s.conns[c]; ok {
delete(s.conns, c)
s.wg.Done()
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"forgetConn",
"(",
"c",
"net",
".",
"Conn",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"s",
".",
"conns",
"[",
"c",
"]",
";",
"ok",
"{",
"delete",
"(",
"s",
".",
"conns",
",",
"c",
")",
"\n",
"s",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// forgetConn removes c from the set of tracked conns and decrements it from the
// waitgroup, unless it was previously removed.
// s.mu must be held.
|
[
"forgetConn",
"removes",
"c",
"from",
"the",
"set",
"of",
"tracked",
"conns",
"and",
"decrements",
"it",
"from",
"the",
"waitgroup",
"unless",
"it",
"was",
"previously",
"removed",
".",
"s",
".",
"mu",
"must",
"be",
"held",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/internal/server.go#L338-L343
|
train
|
vmware/govmomi
|
simulator/property_filter.go
|
matches
|
func (f *PropertyFilter) matches(ctx *Context, ref types.ManagedObjectReference, change *types.PropertyChange) bool {
var kind reflect.Type
for _, p := range f.Spec.PropSet {
if p.Type != ref.Type {
if kind == nil {
kind = getManagedObject(ctx.Map.Get(ref)).Type()
}
// e.g. ManagedEntity, ComputeResource
field, ok := kind.FieldByName(p.Type)
if !(ok && field.Anonymous) {
continue
}
}
if isTrue(p.All) {
return true
}
for _, name := range p.PathSet {
if name == change.Name {
return true
}
// strings.HasPrefix("runtime.powerState", "runtime") == parent field matches
if strings.HasPrefix(change.Name, name) {
if obj := ctx.Map.Get(ref); obj != nil { // object may have since been deleted
change.Name = name
change.Val, _ = fieldValue(reflect.ValueOf(obj), name)
}
return true
}
}
}
return false
}
|
go
|
func (f *PropertyFilter) matches(ctx *Context, ref types.ManagedObjectReference, change *types.PropertyChange) bool {
var kind reflect.Type
for _, p := range f.Spec.PropSet {
if p.Type != ref.Type {
if kind == nil {
kind = getManagedObject(ctx.Map.Get(ref)).Type()
}
// e.g. ManagedEntity, ComputeResource
field, ok := kind.FieldByName(p.Type)
if !(ok && field.Anonymous) {
continue
}
}
if isTrue(p.All) {
return true
}
for _, name := range p.PathSet {
if name == change.Name {
return true
}
// strings.HasPrefix("runtime.powerState", "runtime") == parent field matches
if strings.HasPrefix(change.Name, name) {
if obj := ctx.Map.Get(ref); obj != nil { // object may have since been deleted
change.Name = name
change.Val, _ = fieldValue(reflect.ValueOf(obj), name)
}
return true
}
}
}
return false
}
|
[
"func",
"(",
"f",
"*",
"PropertyFilter",
")",
"matches",
"(",
"ctx",
"*",
"Context",
",",
"ref",
"types",
".",
"ManagedObjectReference",
",",
"change",
"*",
"types",
".",
"PropertyChange",
")",
"bool",
"{",
"var",
"kind",
"reflect",
".",
"Type",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"f",
".",
"Spec",
".",
"PropSet",
"{",
"if",
"p",
".",
"Type",
"!=",
"ref",
".",
"Type",
"{",
"if",
"kind",
"==",
"nil",
"{",
"kind",
"=",
"getManagedObject",
"(",
"ctx",
".",
"Map",
".",
"Get",
"(",
"ref",
")",
")",
".",
"Type",
"(",
")",
"\n",
"}",
"\n",
"field",
",",
"ok",
":=",
"kind",
".",
"FieldByName",
"(",
"p",
".",
"Type",
")",
"\n",
"if",
"!",
"(",
"ok",
"&&",
"field",
".",
"Anonymous",
")",
"{",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"isTrue",
"(",
"p",
".",
"All",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"for",
"_",
",",
"name",
":=",
"range",
"p",
".",
"PathSet",
"{",
"if",
"name",
"==",
"change",
".",
"Name",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"change",
".",
"Name",
",",
"name",
")",
"{",
"if",
"obj",
":=",
"ctx",
".",
"Map",
".",
"Get",
"(",
"ref",
")",
";",
"obj",
"!=",
"nil",
"{",
"change",
".",
"Name",
"=",
"name",
"\n",
"change",
".",
"Val",
",",
"_",
"=",
"fieldValue",
"(",
"reflect",
".",
"ValueOf",
"(",
"obj",
")",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// matches returns true if the change matches one of the filter Spec.PropSet
|
[
"matches",
"returns",
"true",
"if",
"the",
"change",
"matches",
"one",
"of",
"the",
"filter",
"Spec",
".",
"PropSet"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/property_filter.go#L49-L86
|
train
|
vmware/govmomi
|
simulator/property_filter.go
|
apply
|
func (f *PropertyFilter) apply(ctx *Context, change types.ObjectUpdate) types.ObjectUpdate {
parents := make(map[string]bool)
set := change.ChangeSet
change.ChangeSet = nil
for i, p := range set {
if f.matches(ctx, change.Obj, &p) {
if p.Name != set[i].Name {
// update matches a parent field from the spec.
if parents[p.Name] {
continue // only return 1 instance of the parent
}
parents[p.Name] = true
}
change.ChangeSet = append(change.ChangeSet, p)
}
}
return change
}
|
go
|
func (f *PropertyFilter) apply(ctx *Context, change types.ObjectUpdate) types.ObjectUpdate {
parents := make(map[string]bool)
set := change.ChangeSet
change.ChangeSet = nil
for i, p := range set {
if f.matches(ctx, change.Obj, &p) {
if p.Name != set[i].Name {
// update matches a parent field from the spec.
if parents[p.Name] {
continue // only return 1 instance of the parent
}
parents[p.Name] = true
}
change.ChangeSet = append(change.ChangeSet, p)
}
}
return change
}
|
[
"func",
"(",
"f",
"*",
"PropertyFilter",
")",
"apply",
"(",
"ctx",
"*",
"Context",
",",
"change",
"types",
".",
"ObjectUpdate",
")",
"types",
".",
"ObjectUpdate",
"{",
"parents",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"set",
":=",
"change",
".",
"ChangeSet",
"\n",
"change",
".",
"ChangeSet",
"=",
"nil",
"\n",
"for",
"i",
",",
"p",
":=",
"range",
"set",
"{",
"if",
"f",
".",
"matches",
"(",
"ctx",
",",
"change",
".",
"Obj",
",",
"&",
"p",
")",
"{",
"if",
"p",
".",
"Name",
"!=",
"set",
"[",
"i",
"]",
".",
"Name",
"{",
"if",
"parents",
"[",
"p",
".",
"Name",
"]",
"{",
"continue",
"\n",
"}",
"\n",
"parents",
"[",
"p",
".",
"Name",
"]",
"=",
"true",
"\n",
"}",
"\n",
"change",
".",
"ChangeSet",
"=",
"append",
"(",
"change",
".",
"ChangeSet",
",",
"p",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"change",
"\n",
"}"
] |
// apply the PropertyFilter.Spec to the given ObjectUpdate
|
[
"apply",
"the",
"PropertyFilter",
".",
"Spec",
"to",
"the",
"given",
"ObjectUpdate"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/property_filter.go#L89-L108
|
train
|
vmware/govmomi
|
vim25/xml/typeinfo.go
|
getTypeInfo
|
func getTypeInfo(typ reflect.Type) (*typeInfo, error) {
tinfoLock.RLock()
tinfo, ok := tinfoMap[typ]
tinfoLock.RUnlock()
if ok {
return tinfo, nil
}
tinfo = &typeInfo{}
if typ.Kind() == reflect.Struct && typ != nameType {
n := typ.NumField()
for i := 0; i < n; i++ {
f := typ.Field(i)
if f.PkgPath != "" || f.Tag.Get("xml") == "-" {
continue // Private field
}
// For embedded structs, embed its fields.
if f.Anonymous {
t := f.Type
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
if t.Kind() == reflect.Struct {
inner, err := getTypeInfo(t)
if err != nil {
return nil, err
}
if tinfo.xmlname == nil {
tinfo.xmlname = inner.xmlname
}
for _, finfo := range inner.fields {
finfo.idx = append([]int{i}, finfo.idx...)
if err := addFieldInfo(typ, tinfo, &finfo); err != nil {
return nil, err
}
}
continue
}
}
finfo, err := structFieldInfo(typ, &f)
if err != nil {
return nil, err
}
if f.Name == "XMLName" {
tinfo.xmlname = finfo
continue
}
// Add the field if it doesn't conflict with other fields.
if err := addFieldInfo(typ, tinfo, finfo); err != nil {
return nil, err
}
}
}
tinfoLock.Lock()
tinfoMap[typ] = tinfo
tinfoLock.Unlock()
return tinfo, nil
}
|
go
|
func getTypeInfo(typ reflect.Type) (*typeInfo, error) {
tinfoLock.RLock()
tinfo, ok := tinfoMap[typ]
tinfoLock.RUnlock()
if ok {
return tinfo, nil
}
tinfo = &typeInfo{}
if typ.Kind() == reflect.Struct && typ != nameType {
n := typ.NumField()
for i := 0; i < n; i++ {
f := typ.Field(i)
if f.PkgPath != "" || f.Tag.Get("xml") == "-" {
continue // Private field
}
// For embedded structs, embed its fields.
if f.Anonymous {
t := f.Type
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
if t.Kind() == reflect.Struct {
inner, err := getTypeInfo(t)
if err != nil {
return nil, err
}
if tinfo.xmlname == nil {
tinfo.xmlname = inner.xmlname
}
for _, finfo := range inner.fields {
finfo.idx = append([]int{i}, finfo.idx...)
if err := addFieldInfo(typ, tinfo, &finfo); err != nil {
return nil, err
}
}
continue
}
}
finfo, err := structFieldInfo(typ, &f)
if err != nil {
return nil, err
}
if f.Name == "XMLName" {
tinfo.xmlname = finfo
continue
}
// Add the field if it doesn't conflict with other fields.
if err := addFieldInfo(typ, tinfo, finfo); err != nil {
return nil, err
}
}
}
tinfoLock.Lock()
tinfoMap[typ] = tinfo
tinfoLock.Unlock()
return tinfo, nil
}
|
[
"func",
"getTypeInfo",
"(",
"typ",
"reflect",
".",
"Type",
")",
"(",
"*",
"typeInfo",
",",
"error",
")",
"{",
"tinfoLock",
".",
"RLock",
"(",
")",
"\n",
"tinfo",
",",
"ok",
":=",
"tinfoMap",
"[",
"typ",
"]",
"\n",
"tinfoLock",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"ok",
"{",
"return",
"tinfo",
",",
"nil",
"\n",
"}",
"\n",
"tinfo",
"=",
"&",
"typeInfo",
"{",
"}",
"\n",
"if",
"typ",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Struct",
"&&",
"typ",
"!=",
"nameType",
"{",
"n",
":=",
"typ",
".",
"NumField",
"(",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"f",
":=",
"typ",
".",
"Field",
"(",
"i",
")",
"\n",
"if",
"f",
".",
"PkgPath",
"!=",
"\"\"",
"||",
"f",
".",
"Tag",
".",
"Get",
"(",
"\"xml\"",
")",
"==",
"\"-\"",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"f",
".",
"Anonymous",
"{",
"t",
":=",
"f",
".",
"Type",
"\n",
"if",
"t",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"t",
"=",
"t",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n",
"if",
"t",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Struct",
"{",
"inner",
",",
"err",
":=",
"getTypeInfo",
"(",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"tinfo",
".",
"xmlname",
"==",
"nil",
"{",
"tinfo",
".",
"xmlname",
"=",
"inner",
".",
"xmlname",
"\n",
"}",
"\n",
"for",
"_",
",",
"finfo",
":=",
"range",
"inner",
".",
"fields",
"{",
"finfo",
".",
"idx",
"=",
"append",
"(",
"[",
"]",
"int",
"{",
"i",
"}",
",",
"finfo",
".",
"idx",
"...",
")",
"\n",
"if",
"err",
":=",
"addFieldInfo",
"(",
"typ",
",",
"tinfo",
",",
"&",
"finfo",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"finfo",
",",
"err",
":=",
"structFieldInfo",
"(",
"typ",
",",
"&",
"f",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"f",
".",
"Name",
"==",
"\"XMLName\"",
"{",
"tinfo",
".",
"xmlname",
"=",
"finfo",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"err",
":=",
"addFieldInfo",
"(",
"typ",
",",
"tinfo",
",",
"finfo",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"tinfoLock",
".",
"Lock",
"(",
")",
"\n",
"tinfoMap",
"[",
"typ",
"]",
"=",
"tinfo",
"\n",
"tinfoLock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"tinfo",
",",
"nil",
"\n",
"}"
] |
// getTypeInfo returns the typeInfo structure with details necessary
// for marshalling and unmarshalling typ.
|
[
"getTypeInfo",
"returns",
"the",
"typeInfo",
"structure",
"with",
"details",
"necessary",
"for",
"marshalling",
"and",
"unmarshalling",
"typ",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/xml/typeinfo.go#L52-L112
|
train
|
vmware/govmomi
|
vim25/xml/typeinfo.go
|
lookupXMLName
|
func lookupXMLName(typ reflect.Type) (xmlname *fieldInfo) {
for typ.Kind() == reflect.Ptr {
typ = typ.Elem()
}
if typ.Kind() != reflect.Struct {
return nil
}
for i, n := 0, typ.NumField(); i < n; i++ {
f := typ.Field(i)
if f.Name != "XMLName" {
continue
}
finfo, err := structFieldInfo(typ, &f)
if finfo.name != "" && err == nil {
return finfo
}
// Also consider errors as a non-existent field tag
// and let getTypeInfo itself report the error.
break
}
return nil
}
|
go
|
func lookupXMLName(typ reflect.Type) (xmlname *fieldInfo) {
for typ.Kind() == reflect.Ptr {
typ = typ.Elem()
}
if typ.Kind() != reflect.Struct {
return nil
}
for i, n := 0, typ.NumField(); i < n; i++ {
f := typ.Field(i)
if f.Name != "XMLName" {
continue
}
finfo, err := structFieldInfo(typ, &f)
if finfo.name != "" && err == nil {
return finfo
}
// Also consider errors as a non-existent field tag
// and let getTypeInfo itself report the error.
break
}
return nil
}
|
[
"func",
"lookupXMLName",
"(",
"typ",
"reflect",
".",
"Type",
")",
"(",
"xmlname",
"*",
"fieldInfo",
")",
"{",
"for",
"typ",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"typ",
"=",
"typ",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n",
"if",
"typ",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Struct",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"i",
",",
"n",
":=",
"0",
",",
"typ",
".",
"NumField",
"(",
")",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"f",
":=",
"typ",
".",
"Field",
"(",
"i",
")",
"\n",
"if",
"f",
".",
"Name",
"!=",
"\"XMLName\"",
"{",
"continue",
"\n",
"}",
"\n",
"finfo",
",",
"err",
":=",
"structFieldInfo",
"(",
"typ",
",",
"&",
"f",
")",
"\n",
"if",
"finfo",
".",
"name",
"!=",
"\"\"",
"&&",
"err",
"==",
"nil",
"{",
"return",
"finfo",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// lookupXMLName returns the fieldInfo for typ's XMLName field
// in case it exists and has a valid xml field tag, otherwise
// it returns nil.
|
[
"lookupXMLName",
"returns",
"the",
"fieldInfo",
"for",
"typ",
"s",
"XMLName",
"field",
"in",
"case",
"it",
"exists",
"and",
"has",
"a",
"valid",
"xml",
"field",
"tag",
"otherwise",
"it",
"returns",
"nil",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/xml/typeinfo.go#L233-L254
|
train
|
vmware/govmomi
|
vapi/library/library_file.go
|
ListLibraryItemFiles
|
func (c *Manager) ListLibraryItemFiles(ctx context.Context, id string) ([]File, error) {
url := internal.URL(c, internal.LibraryItemFilePath).WithParameter("library_item_id", id)
var res []File
return res, c.Do(ctx, url.Request(http.MethodGet), &res)
}
|
go
|
func (c *Manager) ListLibraryItemFiles(ctx context.Context, id string) ([]File, error) {
url := internal.URL(c, internal.LibraryItemFilePath).WithParameter("library_item_id", id)
var res []File
return res, c.Do(ctx, url.Request(http.MethodGet), &res)
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"ListLibraryItemFiles",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"string",
")",
"(",
"[",
"]",
"File",
",",
"error",
")",
"{",
"url",
":=",
"internal",
".",
"URL",
"(",
"c",
",",
"internal",
".",
"LibraryItemFilePath",
")",
".",
"WithParameter",
"(",
"\"library_item_id\"",
",",
"id",
")",
"\n",
"var",
"res",
"[",
"]",
"File",
"\n",
"return",
"res",
",",
"c",
".",
"Do",
"(",
"ctx",
",",
"url",
".",
"Request",
"(",
"http",
".",
"MethodGet",
")",
",",
"&",
"res",
")",
"\n",
"}"
] |
// ListLibraryItemFiles returns a list of all the files for a library item.
|
[
"ListLibraryItemFiles",
"returns",
"a",
"list",
"of",
"all",
"the",
"files",
"for",
"a",
"library",
"item",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/library/library_file.go#L42-L46
|
train
|
vmware/govmomi
|
vapi/library/library_file.go
|
GetLibraryItemFile
|
func (c *Manager) GetLibraryItemFile(ctx context.Context, id, fileName string) (*File, error) {
url := internal.URL(c, internal.LibraryItemFilePath).WithID(id).WithAction("get")
spec := struct {
Name string `json:"name"`
}{fileName}
var res File
return &res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
}
|
go
|
func (c *Manager) GetLibraryItemFile(ctx context.Context, id, fileName string) (*File, error) {
url := internal.URL(c, internal.LibraryItemFilePath).WithID(id).WithAction("get")
spec := struct {
Name string `json:"name"`
}{fileName}
var res File
return &res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"GetLibraryItemFile",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
",",
"fileName",
"string",
")",
"(",
"*",
"File",
",",
"error",
")",
"{",
"url",
":=",
"internal",
".",
"URL",
"(",
"c",
",",
"internal",
".",
"LibraryItemFilePath",
")",
".",
"WithID",
"(",
"id",
")",
".",
"WithAction",
"(",
"\"get\"",
")",
"\n",
"spec",
":=",
"struct",
"{",
"Name",
"string",
"`json:\"name\"`",
"\n",
"}",
"{",
"fileName",
"}",
"\n",
"var",
"res",
"File",
"\n",
"return",
"&",
"res",
",",
"c",
".",
"Do",
"(",
"ctx",
",",
"url",
".",
"Request",
"(",
"http",
".",
"MethodPost",
",",
"spec",
")",
",",
"&",
"res",
")",
"\n",
"}"
] |
// GetLibraryItemFile returns a file with the provided name for a library item.
|
[
"GetLibraryItemFile",
"returns",
"a",
"file",
"with",
"the",
"provided",
"name",
"for",
"a",
"library",
"item",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/library/library_file.go#L49-L56
|
train
|
vmware/govmomi
|
nfc/lease_updater.go
|
File
|
func (o FileItem) File() types.OvfFile {
return types.OvfFile{
DeviceId: o.DeviceId,
Path: o.Path,
Size: o.Size,
}
}
|
go
|
func (o FileItem) File() types.OvfFile {
return types.OvfFile{
DeviceId: o.DeviceId,
Path: o.Path,
Size: o.Size,
}
}
|
[
"func",
"(",
"o",
"FileItem",
")",
"File",
"(",
")",
"types",
".",
"OvfFile",
"{",
"return",
"types",
".",
"OvfFile",
"{",
"DeviceId",
":",
"o",
".",
"DeviceId",
",",
"Path",
":",
"o",
".",
"Path",
",",
"Size",
":",
"o",
".",
"Size",
",",
"}",
"\n",
"}"
] |
// File converts the FileItem.OvfFileItem to an OvfFile
|
[
"File",
"converts",
"the",
"FileItem",
".",
"OvfFileItem",
"to",
"an",
"OvfFile"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/nfc/lease_updater.go#L51-L57
|
train
|
vmware/govmomi
|
govc/datastore/ls.go
|
hasMultiplePaths
|
func (o *listOutput) hasMultiplePaths() bool {
if len(o.rs) == 0 {
return false
}
p := o.rs[0].FolderPath
// Multiple paths if any entry is not equal to the first one.
for _, e := range o.rs {
if e.FolderPath != p {
return true
}
}
return false
}
|
go
|
func (o *listOutput) hasMultiplePaths() bool {
if len(o.rs) == 0 {
return false
}
p := o.rs[0].FolderPath
// Multiple paths if any entry is not equal to the first one.
for _, e := range o.rs {
if e.FolderPath != p {
return true
}
}
return false
}
|
[
"func",
"(",
"o",
"*",
"listOutput",
")",
"hasMultiplePaths",
"(",
")",
"bool",
"{",
"if",
"len",
"(",
"o",
".",
"rs",
")",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n",
"p",
":=",
"o",
".",
"rs",
"[",
"0",
"]",
".",
"FolderPath",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"o",
".",
"rs",
"{",
"if",
"e",
".",
"FolderPath",
"!=",
"p",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// hasMultiplePaths returns whether or not the slice of search results contains
// results from more than one folder path.
|
[
"hasMultiplePaths",
"returns",
"whether",
"or",
"not",
"the",
"slice",
"of",
"search",
"results",
"contains",
"results",
"from",
"more",
"than",
"one",
"folder",
"path",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/govc/datastore/ls.go#L233-L248
|
train
|
vmware/govmomi
|
vapi/tags/categories.go
|
Patch
|
func (c *Category) Patch(src *Category) {
if src.Name != "" {
c.Name = src.Name
}
if src.Description != "" {
c.Description = src.Description
}
if src.Cardinality != "" {
c.Cardinality = src.Cardinality
}
// Note that in order to append to AssociableTypes any existing types must be included in their original order.
for _, kind := range src.AssociableTypes {
if !c.hasType(kind) {
c.AssociableTypes = append(c.AssociableTypes, kind)
}
}
}
|
go
|
func (c *Category) Patch(src *Category) {
if src.Name != "" {
c.Name = src.Name
}
if src.Description != "" {
c.Description = src.Description
}
if src.Cardinality != "" {
c.Cardinality = src.Cardinality
}
// Note that in order to append to AssociableTypes any existing types must be included in their original order.
for _, kind := range src.AssociableTypes {
if !c.hasType(kind) {
c.AssociableTypes = append(c.AssociableTypes, kind)
}
}
}
|
[
"func",
"(",
"c",
"*",
"Category",
")",
"Patch",
"(",
"src",
"*",
"Category",
")",
"{",
"if",
"src",
".",
"Name",
"!=",
"\"\"",
"{",
"c",
".",
"Name",
"=",
"src",
".",
"Name",
"\n",
"}",
"\n",
"if",
"src",
".",
"Description",
"!=",
"\"\"",
"{",
"c",
".",
"Description",
"=",
"src",
".",
"Description",
"\n",
"}",
"\n",
"if",
"src",
".",
"Cardinality",
"!=",
"\"\"",
"{",
"c",
".",
"Cardinality",
"=",
"src",
".",
"Cardinality",
"\n",
"}",
"\n",
"for",
"_",
",",
"kind",
":=",
"range",
"src",
".",
"AssociableTypes",
"{",
"if",
"!",
"c",
".",
"hasType",
"(",
"kind",
")",
"{",
"c",
".",
"AssociableTypes",
"=",
"append",
"(",
"c",
".",
"AssociableTypes",
",",
"kind",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Patch merges Category changes from the given src.
// AssociableTypes can only be appended to and cannot shrink.
|
[
"Patch",
"merges",
"Category",
"changes",
"from",
"the",
"given",
"src",
".",
"AssociableTypes",
"can",
"only",
"be",
"appended",
"to",
"and",
"cannot",
"shrink",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/tags/categories.go#L48-L64
|
train
|
vmware/govmomi
|
vapi/tags/categories.go
|
CreateCategory
|
func (c *Manager) CreateCategory(ctx context.Context, category *Category) (string, error) {
// create avoids the annoyance of CreateTag requiring field keys to be included in the request,
// even though the field value can be empty.
type create struct {
Name string `json:"name"`
Description string `json:"description"`
Cardinality string `json:"cardinality"`
AssociableTypes []string `json:"associable_types"`
}
spec := struct {
Category create `json:"create_spec"`
}{
Category: create{
Name: category.Name,
Description: category.Description,
Cardinality: category.Cardinality,
AssociableTypes: category.AssociableTypes,
},
}
if spec.Category.AssociableTypes == nil {
// otherwise create fails with invalid_argument
spec.Category.AssociableTypes = []string{}
}
url := internal.URL(c, internal.CategoryPath)
var res string
return res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
}
|
go
|
func (c *Manager) CreateCategory(ctx context.Context, category *Category) (string, error) {
// create avoids the annoyance of CreateTag requiring field keys to be included in the request,
// even though the field value can be empty.
type create struct {
Name string `json:"name"`
Description string `json:"description"`
Cardinality string `json:"cardinality"`
AssociableTypes []string `json:"associable_types"`
}
spec := struct {
Category create `json:"create_spec"`
}{
Category: create{
Name: category.Name,
Description: category.Description,
Cardinality: category.Cardinality,
AssociableTypes: category.AssociableTypes,
},
}
if spec.Category.AssociableTypes == nil {
// otherwise create fails with invalid_argument
spec.Category.AssociableTypes = []string{}
}
url := internal.URL(c, internal.CategoryPath)
var res string
return res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"CreateCategory",
"(",
"ctx",
"context",
".",
"Context",
",",
"category",
"*",
"Category",
")",
"(",
"string",
",",
"error",
")",
"{",
"type",
"create",
"struct",
"{",
"Name",
"string",
"`json:\"name\"`",
"\n",
"Description",
"string",
"`json:\"description\"`",
"\n",
"Cardinality",
"string",
"`json:\"cardinality\"`",
"\n",
"AssociableTypes",
"[",
"]",
"string",
"`json:\"associable_types\"`",
"\n",
"}",
"\n",
"spec",
":=",
"struct",
"{",
"Category",
"create",
"`json:\"create_spec\"`",
"\n",
"}",
"{",
"Category",
":",
"create",
"{",
"Name",
":",
"category",
".",
"Name",
",",
"Description",
":",
"category",
".",
"Description",
",",
"Cardinality",
":",
"category",
".",
"Cardinality",
",",
"AssociableTypes",
":",
"category",
".",
"AssociableTypes",
",",
"}",
",",
"}",
"\n",
"if",
"spec",
".",
"Category",
".",
"AssociableTypes",
"==",
"nil",
"{",
"spec",
".",
"Category",
".",
"AssociableTypes",
"=",
"[",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n",
"url",
":=",
"internal",
".",
"URL",
"(",
"c",
",",
"internal",
".",
"CategoryPath",
")",
"\n",
"var",
"res",
"string",
"\n",
"return",
"res",
",",
"c",
".",
"Do",
"(",
"ctx",
",",
"url",
".",
"Request",
"(",
"http",
".",
"MethodPost",
",",
"spec",
")",
",",
"&",
"res",
")",
"\n",
"}"
] |
// CreateCategory creates a new category and returns the category ID.
|
[
"CreateCategory",
"creates",
"a",
"new",
"category",
"and",
"returns",
"the",
"category",
"ID",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/tags/categories.go#L67-L93
|
train
|
vmware/govmomi
|
vapi/tags/categories.go
|
UpdateCategory
|
func (c *Manager) UpdateCategory(ctx context.Context, category *Category) error {
spec := struct {
Category Category `json:"update_spec"`
}{
Category: Category{
AssociableTypes: category.AssociableTypes,
Cardinality: category.Cardinality,
Description: category.Description,
Name: category.Name,
},
}
url := internal.URL(c, internal.CategoryPath).WithID(category.ID)
return c.Do(ctx, url.Request(http.MethodPatch, spec), nil)
}
|
go
|
func (c *Manager) UpdateCategory(ctx context.Context, category *Category) error {
spec := struct {
Category Category `json:"update_spec"`
}{
Category: Category{
AssociableTypes: category.AssociableTypes,
Cardinality: category.Cardinality,
Description: category.Description,
Name: category.Name,
},
}
url := internal.URL(c, internal.CategoryPath).WithID(category.ID)
return c.Do(ctx, url.Request(http.MethodPatch, spec), nil)
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"UpdateCategory",
"(",
"ctx",
"context",
".",
"Context",
",",
"category",
"*",
"Category",
")",
"error",
"{",
"spec",
":=",
"struct",
"{",
"Category",
"Category",
"`json:\"update_spec\"`",
"\n",
"}",
"{",
"Category",
":",
"Category",
"{",
"AssociableTypes",
":",
"category",
".",
"AssociableTypes",
",",
"Cardinality",
":",
"category",
".",
"Cardinality",
",",
"Description",
":",
"category",
".",
"Description",
",",
"Name",
":",
"category",
".",
"Name",
",",
"}",
",",
"}",
"\n",
"url",
":=",
"internal",
".",
"URL",
"(",
"c",
",",
"internal",
".",
"CategoryPath",
")",
".",
"WithID",
"(",
"category",
".",
"ID",
")",
"\n",
"return",
"c",
".",
"Do",
"(",
"ctx",
",",
"url",
".",
"Request",
"(",
"http",
".",
"MethodPatch",
",",
"spec",
")",
",",
"nil",
")",
"\n",
"}"
] |
// UpdateCategory can update one or more of the AssociableTypes, Cardinality, Description and Name fields.
|
[
"UpdateCategory",
"can",
"update",
"one",
"or",
"more",
"of",
"the",
"AssociableTypes",
"Cardinality",
"Description",
"and",
"Name",
"fields",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/tags/categories.go#L96-L109
|
train
|
vmware/govmomi
|
vapi/tags/categories.go
|
DeleteCategory
|
func (c *Manager) DeleteCategory(ctx context.Context, category *Category) error {
url := internal.URL(c, internal.CategoryPath).WithID(category.ID)
return c.Do(ctx, url.Request(http.MethodDelete), nil)
}
|
go
|
func (c *Manager) DeleteCategory(ctx context.Context, category *Category) error {
url := internal.URL(c, internal.CategoryPath).WithID(category.ID)
return c.Do(ctx, url.Request(http.MethodDelete), nil)
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"DeleteCategory",
"(",
"ctx",
"context",
".",
"Context",
",",
"category",
"*",
"Category",
")",
"error",
"{",
"url",
":=",
"internal",
".",
"URL",
"(",
"c",
",",
"internal",
".",
"CategoryPath",
")",
".",
"WithID",
"(",
"category",
".",
"ID",
")",
"\n",
"return",
"c",
".",
"Do",
"(",
"ctx",
",",
"url",
".",
"Request",
"(",
"http",
".",
"MethodDelete",
")",
",",
"nil",
")",
"\n",
"}"
] |
// DeleteCategory deletes an existing category.
|
[
"DeleteCategory",
"deletes",
"an",
"existing",
"category",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/tags/categories.go#L112-L115
|
train
|
vmware/govmomi
|
vapi/tags/categories.go
|
GetCategory
|
func (c *Manager) GetCategory(ctx context.Context, id string) (*Category, error) {
if isName(id) {
cat, err := c.GetCategories(ctx)
if err != nil {
return nil, err
}
for i := range cat {
if cat[i].Name == id {
return &cat[i], nil
}
}
}
url := internal.URL(c, internal.CategoryPath).WithID(id)
var res Category
return &res, c.Do(ctx, url.Request(http.MethodGet), &res)
}
|
go
|
func (c *Manager) GetCategory(ctx context.Context, id string) (*Category, error) {
if isName(id) {
cat, err := c.GetCategories(ctx)
if err != nil {
return nil, err
}
for i := range cat {
if cat[i].Name == id {
return &cat[i], nil
}
}
}
url := internal.URL(c, internal.CategoryPath).WithID(id)
var res Category
return &res, c.Do(ctx, url.Request(http.MethodGet), &res)
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"GetCategory",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"string",
")",
"(",
"*",
"Category",
",",
"error",
")",
"{",
"if",
"isName",
"(",
"id",
")",
"{",
"cat",
",",
"err",
":=",
"c",
".",
"GetCategories",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"cat",
"{",
"if",
"cat",
"[",
"i",
"]",
".",
"Name",
"==",
"id",
"{",
"return",
"&",
"cat",
"[",
"i",
"]",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"url",
":=",
"internal",
".",
"URL",
"(",
"c",
",",
"internal",
".",
"CategoryPath",
")",
".",
"WithID",
"(",
"id",
")",
"\n",
"var",
"res",
"Category",
"\n",
"return",
"&",
"res",
",",
"c",
".",
"Do",
"(",
"ctx",
",",
"url",
".",
"Request",
"(",
"http",
".",
"MethodGet",
")",
",",
"&",
"res",
")",
"\n",
"}"
] |
// GetCategory fetches the category information for the given identifier.
// The id parameter can be a Category ID or Category Name.
|
[
"GetCategory",
"fetches",
"the",
"category",
"information",
"for",
"the",
"given",
"identifier",
".",
"The",
"id",
"parameter",
"can",
"be",
"a",
"Category",
"ID",
"or",
"Category",
"Name",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/tags/categories.go#L119-L135
|
train
|
vmware/govmomi
|
vapi/tags/categories.go
|
ListCategories
|
func (c *Manager) ListCategories(ctx context.Context) ([]string, error) {
url := internal.URL(c, internal.CategoryPath)
var res []string
return res, c.Do(ctx, url.Request(http.MethodGet), &res)
}
|
go
|
func (c *Manager) ListCategories(ctx context.Context) ([]string, error) {
url := internal.URL(c, internal.CategoryPath)
var res []string
return res, c.Do(ctx, url.Request(http.MethodGet), &res)
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"ListCategories",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"url",
":=",
"internal",
".",
"URL",
"(",
"c",
",",
"internal",
".",
"CategoryPath",
")",
"\n",
"var",
"res",
"[",
"]",
"string",
"\n",
"return",
"res",
",",
"c",
".",
"Do",
"(",
"ctx",
",",
"url",
".",
"Request",
"(",
"http",
".",
"MethodGet",
")",
",",
"&",
"res",
")",
"\n",
"}"
] |
// ListCategories returns all category IDs in the system.
|
[
"ListCategories",
"returns",
"all",
"category",
"IDs",
"in",
"the",
"system",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/tags/categories.go#L138-L142
|
train
|
vmware/govmomi
|
vapi/tags/categories.go
|
GetCategories
|
func (c *Manager) GetCategories(ctx context.Context) ([]Category, error) {
ids, err := c.ListCategories(ctx)
if err != nil {
return nil, fmt.Errorf("list categories: %s", err)
}
var categories []Category
for _, id := range ids {
category, err := c.GetCategory(ctx, id)
if err != nil {
return nil, fmt.Errorf("get category %s: %s", id, err)
}
categories = append(categories, *category)
}
return categories, nil
}
|
go
|
func (c *Manager) GetCategories(ctx context.Context) ([]Category, error) {
ids, err := c.ListCategories(ctx)
if err != nil {
return nil, fmt.Errorf("list categories: %s", err)
}
var categories []Category
for _, id := range ids {
category, err := c.GetCategory(ctx, id)
if err != nil {
return nil, fmt.Errorf("get category %s: %s", id, err)
}
categories = append(categories, *category)
}
return categories, nil
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"GetCategories",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"Category",
",",
"error",
")",
"{",
"ids",
",",
"err",
":=",
"c",
".",
"ListCategories",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"list categories: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"var",
"categories",
"[",
"]",
"Category",
"\n",
"for",
"_",
",",
"id",
":=",
"range",
"ids",
"{",
"category",
",",
"err",
":=",
"c",
".",
"GetCategory",
"(",
"ctx",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"get category %s: %s\"",
",",
"id",
",",
"err",
")",
"\n",
"}",
"\n",
"categories",
"=",
"append",
"(",
"categories",
",",
"*",
"category",
")",
"\n",
"}",
"\n",
"return",
"categories",
",",
"nil",
"\n",
"}"
] |
// GetCategories fetches an array of category information in the system.
|
[
"GetCategories",
"fetches",
"an",
"array",
"of",
"category",
"information",
"in",
"the",
"system",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/tags/categories.go#L145-L162
|
train
|
vmware/govmomi
|
vapi/simulator/simulator.go
|
New
|
func New(u *url.URL, settings []vim.BaseOptionValue) (string, http.Handler) {
s := &handler{
ServeMux: http.NewServeMux(),
URL: *u,
Category: make(map[string]*tags.Category),
Tag: make(map[string]*tags.Tag),
Association: make(map[string]map[internal.AssociatedObject]bool),
Session: make(map[string]*session),
Library: make(map[string]content),
Update: make(map[string]update),
}
handlers := []struct {
p string
m http.HandlerFunc
}{
{internal.SessionPath, s.session},
{internal.CategoryPath, s.category},
{internal.CategoryPath + "/", s.categoryID},
{internal.TagPath, s.tag},
{internal.TagPath + "/", s.tagID},
{internal.AssociationPath, s.association},
{internal.AssociationPath + "/", s.associationID},
{internal.LibraryPath, s.library},
{internal.LocalLibraryPath, s.library},
{internal.LibraryPath + "/", s.libraryID},
{internal.LocalLibraryPath + "/", s.libraryID},
{internal.LibraryItemPath, s.libraryItem},
{internal.LibraryItemPath + "/", s.libraryItemID},
{internal.LibraryItemUpdateSession, s.libraryItemUpdateSession},
{internal.LibraryItemUpdateSession + "/", s.libraryItemUpdateSessionID},
{internal.LibraryItemUpdateSessionFile, s.libraryItemUpdateSessionFile},
{internal.LibraryItemUpdateSessionFile + "/", s.libraryItemUpdateSessionFileID},
{internal.LibraryItemAdd + "/", s.libraryItemAdd},
{internal.LibraryItemFilePath, s.libraryItemFile},
{internal.LibraryItemFilePath + "/", s.libraryItemFileID},
{internal.VCenterOVFLibraryItem + "/", s.libraryItemDeployID},
}
for i := range handlers {
h := handlers[i]
s.HandleFunc(internal.Path+h.p, func(w http.ResponseWriter, r *http.Request) {
s.Lock()
defer s.Unlock()
if !s.isAuthorized(r) {
w.WriteHeader(http.StatusUnauthorized)
return
}
h.m(w, r)
})
}
return internal.Path + "/", s
}
|
go
|
func New(u *url.URL, settings []vim.BaseOptionValue) (string, http.Handler) {
s := &handler{
ServeMux: http.NewServeMux(),
URL: *u,
Category: make(map[string]*tags.Category),
Tag: make(map[string]*tags.Tag),
Association: make(map[string]map[internal.AssociatedObject]bool),
Session: make(map[string]*session),
Library: make(map[string]content),
Update: make(map[string]update),
}
handlers := []struct {
p string
m http.HandlerFunc
}{
{internal.SessionPath, s.session},
{internal.CategoryPath, s.category},
{internal.CategoryPath + "/", s.categoryID},
{internal.TagPath, s.tag},
{internal.TagPath + "/", s.tagID},
{internal.AssociationPath, s.association},
{internal.AssociationPath + "/", s.associationID},
{internal.LibraryPath, s.library},
{internal.LocalLibraryPath, s.library},
{internal.LibraryPath + "/", s.libraryID},
{internal.LocalLibraryPath + "/", s.libraryID},
{internal.LibraryItemPath, s.libraryItem},
{internal.LibraryItemPath + "/", s.libraryItemID},
{internal.LibraryItemUpdateSession, s.libraryItemUpdateSession},
{internal.LibraryItemUpdateSession + "/", s.libraryItemUpdateSessionID},
{internal.LibraryItemUpdateSessionFile, s.libraryItemUpdateSessionFile},
{internal.LibraryItemUpdateSessionFile + "/", s.libraryItemUpdateSessionFileID},
{internal.LibraryItemAdd + "/", s.libraryItemAdd},
{internal.LibraryItemFilePath, s.libraryItemFile},
{internal.LibraryItemFilePath + "/", s.libraryItemFileID},
{internal.VCenterOVFLibraryItem + "/", s.libraryItemDeployID},
}
for i := range handlers {
h := handlers[i]
s.HandleFunc(internal.Path+h.p, func(w http.ResponseWriter, r *http.Request) {
s.Lock()
defer s.Unlock()
if !s.isAuthorized(r) {
w.WriteHeader(http.StatusUnauthorized)
return
}
h.m(w, r)
})
}
return internal.Path + "/", s
}
|
[
"func",
"New",
"(",
"u",
"*",
"url",
".",
"URL",
",",
"settings",
"[",
"]",
"vim",
".",
"BaseOptionValue",
")",
"(",
"string",
",",
"http",
".",
"Handler",
")",
"{",
"s",
":=",
"&",
"handler",
"{",
"ServeMux",
":",
"http",
".",
"NewServeMux",
"(",
")",
",",
"URL",
":",
"*",
"u",
",",
"Category",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"tags",
".",
"Category",
")",
",",
"Tag",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"tags",
".",
"Tag",
")",
",",
"Association",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"internal",
".",
"AssociatedObject",
"]",
"bool",
")",
",",
"Session",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"session",
")",
",",
"Library",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"content",
")",
",",
"Update",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"update",
")",
",",
"}",
"\n",
"handlers",
":=",
"[",
"]",
"struct",
"{",
"p",
"string",
"\n",
"m",
"http",
".",
"HandlerFunc",
"\n",
"}",
"{",
"{",
"internal",
".",
"SessionPath",
",",
"s",
".",
"session",
"}",
",",
"{",
"internal",
".",
"CategoryPath",
",",
"s",
".",
"category",
"}",
",",
"{",
"internal",
".",
"CategoryPath",
"+",
"\"/\"",
",",
"s",
".",
"categoryID",
"}",
",",
"{",
"internal",
".",
"TagPath",
",",
"s",
".",
"tag",
"}",
",",
"{",
"internal",
".",
"TagPath",
"+",
"\"/\"",
",",
"s",
".",
"tagID",
"}",
",",
"{",
"internal",
".",
"AssociationPath",
",",
"s",
".",
"association",
"}",
",",
"{",
"internal",
".",
"AssociationPath",
"+",
"\"/\"",
",",
"s",
".",
"associationID",
"}",
",",
"{",
"internal",
".",
"LibraryPath",
",",
"s",
".",
"library",
"}",
",",
"{",
"internal",
".",
"LocalLibraryPath",
",",
"s",
".",
"library",
"}",
",",
"{",
"internal",
".",
"LibraryPath",
"+",
"\"/\"",
",",
"s",
".",
"libraryID",
"}",
",",
"{",
"internal",
".",
"LocalLibraryPath",
"+",
"\"/\"",
",",
"s",
".",
"libraryID",
"}",
",",
"{",
"internal",
".",
"LibraryItemPath",
",",
"s",
".",
"libraryItem",
"}",
",",
"{",
"internal",
".",
"LibraryItemPath",
"+",
"\"/\"",
",",
"s",
".",
"libraryItemID",
"}",
",",
"{",
"internal",
".",
"LibraryItemUpdateSession",
",",
"s",
".",
"libraryItemUpdateSession",
"}",
",",
"{",
"internal",
".",
"LibraryItemUpdateSession",
"+",
"\"/\"",
",",
"s",
".",
"libraryItemUpdateSessionID",
"}",
",",
"{",
"internal",
".",
"LibraryItemUpdateSessionFile",
",",
"s",
".",
"libraryItemUpdateSessionFile",
"}",
",",
"{",
"internal",
".",
"LibraryItemUpdateSessionFile",
"+",
"\"/\"",
",",
"s",
".",
"libraryItemUpdateSessionFileID",
"}",
",",
"{",
"internal",
".",
"LibraryItemAdd",
"+",
"\"/\"",
",",
"s",
".",
"libraryItemAdd",
"}",
",",
"{",
"internal",
".",
"LibraryItemFilePath",
",",
"s",
".",
"libraryItemFile",
"}",
",",
"{",
"internal",
".",
"LibraryItemFilePath",
"+",
"\"/\"",
",",
"s",
".",
"libraryItemFileID",
"}",
",",
"{",
"internal",
".",
"VCenterOVFLibraryItem",
"+",
"\"/\"",
",",
"s",
".",
"libraryItemDeployID",
"}",
",",
"}",
"\n",
"for",
"i",
":=",
"range",
"handlers",
"{",
"h",
":=",
"handlers",
"[",
"i",
"]",
"\n",
"s",
".",
"HandleFunc",
"(",
"internal",
".",
"Path",
"+",
"h",
".",
"p",
",",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"s",
".",
"isAuthorized",
"(",
"r",
")",
"{",
"w",
".",
"WriteHeader",
"(",
"http",
".",
"StatusUnauthorized",
")",
"\n",
"return",
"\n",
"}",
"\n",
"h",
".",
"m",
"(",
"w",
",",
"r",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"return",
"internal",
".",
"Path",
"+",
"\"/\"",
",",
"s",
"\n",
"}"
] |
// New creates a vAPI simulator.
|
[
"New",
"creates",
"a",
"vAPI",
"simulator",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/simulator/simulator.go#L85-L140
|
train
|
vmware/govmomi
|
vapi/simulator/simulator.go
|
AttachedObjects
|
func (s *handler) AttachedObjects(tag vim.VslmTagEntry) ([]vim.ManagedObjectReference, vim.BaseMethodFault) {
t := s.findTag(tag)
if t == nil {
return nil, new(vim.NotFound)
}
var ids []vim.ManagedObjectReference
for id := range s.Association[t.ID] {
ids = append(ids, vim.ManagedObjectReference(id))
}
return ids, nil
}
|
go
|
func (s *handler) AttachedObjects(tag vim.VslmTagEntry) ([]vim.ManagedObjectReference, vim.BaseMethodFault) {
t := s.findTag(tag)
if t == nil {
return nil, new(vim.NotFound)
}
var ids []vim.ManagedObjectReference
for id := range s.Association[t.ID] {
ids = append(ids, vim.ManagedObjectReference(id))
}
return ids, nil
}
|
[
"func",
"(",
"s",
"*",
"handler",
")",
"AttachedObjects",
"(",
"tag",
"vim",
".",
"VslmTagEntry",
")",
"(",
"[",
"]",
"vim",
".",
"ManagedObjectReference",
",",
"vim",
".",
"BaseMethodFault",
")",
"{",
"t",
":=",
"s",
".",
"findTag",
"(",
"tag",
")",
"\n",
"if",
"t",
"==",
"nil",
"{",
"return",
"nil",
",",
"new",
"(",
"vim",
".",
"NotFound",
")",
"\n",
"}",
"\n",
"var",
"ids",
"[",
"]",
"vim",
".",
"ManagedObjectReference",
"\n",
"for",
"id",
":=",
"range",
"s",
".",
"Association",
"[",
"t",
".",
"ID",
"]",
"{",
"ids",
"=",
"append",
"(",
"ids",
",",
"vim",
".",
"ManagedObjectReference",
"(",
"id",
")",
")",
"\n",
"}",
"\n",
"return",
"ids",
",",
"nil",
"\n",
"}"
] |
// AttachedObjects is meant for internal use via simulator.Registry.tagManager
|
[
"AttachedObjects",
"is",
"meant",
"for",
"internal",
"use",
"via",
"simulator",
".",
"Registry",
".",
"tagManager"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/simulator/simulator.go#L188-L198
|
train
|
vmware/govmomi
|
vapi/simulator/simulator.go
|
AttachedTags
|
func (s *handler) AttachedTags(ref vim.ManagedObjectReference) ([]vim.VslmTagEntry, vim.BaseMethodFault) {
oid := internal.AssociatedObject(ref)
var tags []vim.VslmTagEntry
for id, objs := range s.Association {
if objs[oid] {
tag := s.Tag[id]
cat := s.Category[tag.CategoryID]
tags = append(tags, vim.VslmTagEntry{
TagName: tag.Name,
ParentCategoryName: cat.Name,
})
}
}
return tags, nil
}
|
go
|
func (s *handler) AttachedTags(ref vim.ManagedObjectReference) ([]vim.VslmTagEntry, vim.BaseMethodFault) {
oid := internal.AssociatedObject(ref)
var tags []vim.VslmTagEntry
for id, objs := range s.Association {
if objs[oid] {
tag := s.Tag[id]
cat := s.Category[tag.CategoryID]
tags = append(tags, vim.VslmTagEntry{
TagName: tag.Name,
ParentCategoryName: cat.Name,
})
}
}
return tags, nil
}
|
[
"func",
"(",
"s",
"*",
"handler",
")",
"AttachedTags",
"(",
"ref",
"vim",
".",
"ManagedObjectReference",
")",
"(",
"[",
"]",
"vim",
".",
"VslmTagEntry",
",",
"vim",
".",
"BaseMethodFault",
")",
"{",
"oid",
":=",
"internal",
".",
"AssociatedObject",
"(",
"ref",
")",
"\n",
"var",
"tags",
"[",
"]",
"vim",
".",
"VslmTagEntry",
"\n",
"for",
"id",
",",
"objs",
":=",
"range",
"s",
".",
"Association",
"{",
"if",
"objs",
"[",
"oid",
"]",
"{",
"tag",
":=",
"s",
".",
"Tag",
"[",
"id",
"]",
"\n",
"cat",
":=",
"s",
".",
"Category",
"[",
"tag",
".",
"CategoryID",
"]",
"\n",
"tags",
"=",
"append",
"(",
"tags",
",",
"vim",
".",
"VslmTagEntry",
"{",
"TagName",
":",
"tag",
".",
"Name",
",",
"ParentCategoryName",
":",
"cat",
".",
"Name",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"tags",
",",
"nil",
"\n",
"}"
] |
// AttachedTags is meant for internal use via simulator.Registry.tagManager
|
[
"AttachedTags",
"is",
"meant",
"for",
"internal",
"use",
"via",
"simulator",
".",
"Registry",
".",
"tagManager"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/simulator/simulator.go#L201-L215
|
train
|
vmware/govmomi
|
vapi/simulator/simulator.go
|
AttachTag
|
func (s *handler) AttachTag(ref vim.ManagedObjectReference, tag vim.VslmTagEntry) vim.BaseMethodFault {
t := s.findTag(tag)
if t == nil {
return new(vim.NotFound)
}
s.Association[t.ID][internal.AssociatedObject(ref)] = true
return nil
}
|
go
|
func (s *handler) AttachTag(ref vim.ManagedObjectReference, tag vim.VslmTagEntry) vim.BaseMethodFault {
t := s.findTag(tag)
if t == nil {
return new(vim.NotFound)
}
s.Association[t.ID][internal.AssociatedObject(ref)] = true
return nil
}
|
[
"func",
"(",
"s",
"*",
"handler",
")",
"AttachTag",
"(",
"ref",
"vim",
".",
"ManagedObjectReference",
",",
"tag",
"vim",
".",
"VslmTagEntry",
")",
"vim",
".",
"BaseMethodFault",
"{",
"t",
":=",
"s",
".",
"findTag",
"(",
"tag",
")",
"\n",
"if",
"t",
"==",
"nil",
"{",
"return",
"new",
"(",
"vim",
".",
"NotFound",
")",
"\n",
"}",
"\n",
"s",
".",
"Association",
"[",
"t",
".",
"ID",
"]",
"[",
"internal",
".",
"AssociatedObject",
"(",
"ref",
")",
"]",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// AttachTag is meant for internal use via simulator.Registry.tagManager
|
[
"AttachTag",
"is",
"meant",
"for",
"internal",
"use",
"via",
"simulator",
".",
"Registry",
".",
"tagManager"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/simulator/simulator.go#L218-L225
|
train
|
vmware/govmomi
|
vapi/simulator/simulator.go
|
DetachTag
|
func (s *handler) DetachTag(id vim.ManagedObjectReference, tag vim.VslmTagEntry) vim.BaseMethodFault {
t := s.findTag(tag)
if t == nil {
return new(vim.NotFound)
}
delete(s.Association[t.ID], internal.AssociatedObject(id))
return nil
}
|
go
|
func (s *handler) DetachTag(id vim.ManagedObjectReference, tag vim.VslmTagEntry) vim.BaseMethodFault {
t := s.findTag(tag)
if t == nil {
return new(vim.NotFound)
}
delete(s.Association[t.ID], internal.AssociatedObject(id))
return nil
}
|
[
"func",
"(",
"s",
"*",
"handler",
")",
"DetachTag",
"(",
"id",
"vim",
".",
"ManagedObjectReference",
",",
"tag",
"vim",
".",
"VslmTagEntry",
")",
"vim",
".",
"BaseMethodFault",
"{",
"t",
":=",
"s",
".",
"findTag",
"(",
"tag",
")",
"\n",
"if",
"t",
"==",
"nil",
"{",
"return",
"new",
"(",
"vim",
".",
"NotFound",
")",
"\n",
"}",
"\n",
"delete",
"(",
"s",
".",
"Association",
"[",
"t",
".",
"ID",
"]",
",",
"internal",
".",
"AssociatedObject",
"(",
"id",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// DetachTag is meant for internal use via simulator.Registry.tagManager
|
[
"DetachTag",
"is",
"meant",
"for",
"internal",
"use",
"via",
"simulator",
".",
"Registry",
".",
"tagManager"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/simulator/simulator.go#L228-L235
|
train
|
vmware/govmomi
|
vapi/simulator/simulator.go
|
ok
|
func (s *handler) ok(w http.ResponseWriter, val ...interface{}) {
w.WriteHeader(http.StatusOK)
if len(val) == 0 {
return
}
err := json.NewEncoder(w).Encode(struct {
Value interface{} `json:"value,omitempty"`
}{
val[0],
})
if err != nil {
log.Panic(err)
}
}
|
go
|
func (s *handler) ok(w http.ResponseWriter, val ...interface{}) {
w.WriteHeader(http.StatusOK)
if len(val) == 0 {
return
}
err := json.NewEncoder(w).Encode(struct {
Value interface{} `json:"value,omitempty"`
}{
val[0],
})
if err != nil {
log.Panic(err)
}
}
|
[
"func",
"(",
"s",
"*",
"handler",
")",
"ok",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"val",
"...",
"interface",
"{",
"}",
")",
"{",
"w",
".",
"WriteHeader",
"(",
"http",
".",
"StatusOK",
")",
"\n",
"if",
"len",
"(",
"val",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"err",
":=",
"json",
".",
"NewEncoder",
"(",
"w",
")",
".",
"Encode",
"(",
"struct",
"{",
"Value",
"interface",
"{",
"}",
"`json:\"value,omitempty\"`",
"\n",
"}",
"{",
"val",
"[",
"0",
"]",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// ok responds with http.StatusOK and json encodes val if given.
|
[
"ok",
"responds",
"with",
"http",
".",
"StatusOK",
"and",
"json",
"encodes",
"val",
"if",
"given",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/simulator/simulator.go#L238-L254
|
train
|
vmware/govmomi
|
vapi/simulator/simulator.go
|
ServeHTTP
|
func (s *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodPost, http.MethodDelete, http.MethodGet, http.MethodPatch, http.MethodPut:
default:
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
h, _ := s.Handler(r)
h.ServeHTTP(w, r)
}
|
go
|
func (s *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodPost, http.MethodDelete, http.MethodGet, http.MethodPatch, http.MethodPut:
default:
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
h, _ := s.Handler(r)
h.ServeHTTP(w, r)
}
|
[
"func",
"(",
"s",
"*",
"handler",
")",
"ServeHTTP",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"switch",
"r",
".",
"Method",
"{",
"case",
"http",
".",
"MethodPost",
",",
"http",
".",
"MethodDelete",
",",
"http",
".",
"MethodGet",
",",
"http",
".",
"MethodPatch",
",",
"http",
".",
"MethodPut",
":",
"default",
":",
"w",
".",
"WriteHeader",
"(",
"http",
".",
"StatusMethodNotAllowed",
")",
"\n",
"return",
"\n",
"}",
"\n",
"h",
",",
"_",
":=",
"s",
".",
"Handler",
"(",
"r",
")",
"\n",
"h",
".",
"ServeHTTP",
"(",
"w",
",",
"r",
")",
"\n",
"}"
] |
// ServeHTTP handles vAPI requests.
|
[
"ServeHTTP",
"handles",
"vAPI",
"requests",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/simulator/simulator.go#L279-L289
|
train
|
vmware/govmomi
|
vapi/simulator/simulator.go
|
libraryPath
|
func libraryPath(l *library.Library, id string) string {
// DatastoreID (moref) format is "$local-path@$ds-folder-id",
// see simulator.HostDatastoreSystem.CreateLocalDatastore
ds := strings.SplitN(l.Storage[0].DatastoreID, "@", 2)[0]
return path.Join(append([]string{ds, "contentlib-" + l.ID}, id)...)
}
|
go
|
func libraryPath(l *library.Library, id string) string {
// DatastoreID (moref) format is "$local-path@$ds-folder-id",
// see simulator.HostDatastoreSystem.CreateLocalDatastore
ds := strings.SplitN(l.Storage[0].DatastoreID, "@", 2)[0]
return path.Join(append([]string{ds, "contentlib-" + l.ID}, id)...)
}
|
[
"func",
"libraryPath",
"(",
"l",
"*",
"library",
".",
"Library",
",",
"id",
"string",
")",
"string",
"{",
"ds",
":=",
"strings",
".",
"SplitN",
"(",
"l",
".",
"Storage",
"[",
"0",
"]",
".",
"DatastoreID",
",",
"\"@\"",
",",
"2",
")",
"[",
"0",
"]",
"\n",
"return",
"path",
".",
"Join",
"(",
"append",
"(",
"[",
"]",
"string",
"{",
"ds",
",",
"\"contentlib-\"",
"+",
"l",
".",
"ID",
"}",
",",
"id",
")",
"...",
")",
"\n",
"}"
] |
// libraryPath returns the local Datastore fs path for a Library or Item if id is specified.
|
[
"libraryPath",
"returns",
"the",
"local",
"Datastore",
"fs",
"path",
"for",
"a",
"Library",
"or",
"Item",
"if",
"id",
"is",
"specified",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/simulator/simulator.go#L898-L903
|
train
|
vmware/govmomi
|
govc/library/ova.go
|
NewOVAFile
|
func NewOVAFile(filename string) (*OVAFile, error) {
f, err := os.Open(filename)
if err != nil {
return nil, err
}
tarFile := tar.NewReader(f)
return &OVAFile{filename: filename, file: f, tarFile: tarFile}, nil
}
|
go
|
func NewOVAFile(filename string) (*OVAFile, error) {
f, err := os.Open(filename)
if err != nil {
return nil, err
}
tarFile := tar.NewReader(f)
return &OVAFile{filename: filename, file: f, tarFile: tarFile}, nil
}
|
[
"func",
"NewOVAFile",
"(",
"filename",
"string",
")",
"(",
"*",
"OVAFile",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"tarFile",
":=",
"tar",
".",
"NewReader",
"(",
"f",
")",
"\n",
"return",
"&",
"OVAFile",
"{",
"filename",
":",
"filename",
",",
"file",
":",
"f",
",",
"tarFile",
":",
"tarFile",
"}",
",",
"nil",
"\n",
"}"
] |
// NewOVAFile creates a new OVA file reader
|
[
"NewOVAFile",
"creates",
"a",
"new",
"OVA",
"file",
"reader"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/govc/library/ova.go#L87-L94
|
train
|
vmware/govmomi
|
govc/library/ova.go
|
Find
|
func (of *OVAFile) Find(filename string) (*tar.Header, error) {
for {
header, err := of.tarFile.Next()
if err == io.EOF {
return nil, err
}
if header.Name == filename {
return header, nil
}
}
}
|
go
|
func (of *OVAFile) Find(filename string) (*tar.Header, error) {
for {
header, err := of.tarFile.Next()
if err == io.EOF {
return nil, err
}
if header.Name == filename {
return header, nil
}
}
}
|
[
"func",
"(",
"of",
"*",
"OVAFile",
")",
"Find",
"(",
"filename",
"string",
")",
"(",
"*",
"tar",
".",
"Header",
",",
"error",
")",
"{",
"for",
"{",
"header",
",",
"err",
":=",
"of",
".",
"tarFile",
".",
"Next",
"(",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"header",
".",
"Name",
"==",
"filename",
"{",
"return",
"header",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Find looks for a filename match in the OVA file
|
[
"Find",
"looks",
"for",
"a",
"filename",
"match",
"in",
"the",
"OVA",
"file"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/govc/library/ova.go#L97-L107
|
train
|
vmware/govmomi
|
govc/library/ova.go
|
Read
|
func (of *OVAFile) Read(b []byte) (int, error) {
if of.tarFile == nil {
return 0, io.EOF
}
return of.tarFile.Read(b)
}
|
go
|
func (of *OVAFile) Read(b []byte) (int, error) {
if of.tarFile == nil {
return 0, io.EOF
}
return of.tarFile.Read(b)
}
|
[
"func",
"(",
"of",
"*",
"OVAFile",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"of",
".",
"tarFile",
"==",
"nil",
"{",
"return",
"0",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"return",
"of",
".",
"tarFile",
".",
"Read",
"(",
"b",
")",
"\n",
"}"
] |
// Read reads from the current file in the OVA file
|
[
"Read",
"reads",
"from",
"the",
"current",
"file",
"in",
"the",
"OVA",
"file"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/govc/library/ova.go#L115-L120
|
train
|
vmware/govmomi
|
govc/library/ova.go
|
getOVAFileInfo
|
func getOVAFileInfo(ovafile string, filename string) (int64, string, error) {
of, err := NewOVAFile(ovafile)
if err != nil {
return 0, "", err
}
hdr, err := of.Find(filename)
if err != nil {
return 0, "", err
}
hash := md5.New()
_, err = io.Copy(hash, of)
if err != nil {
return 0, "", err
}
md5String := hex.EncodeToString(hash.Sum(nil)[:16])
return hdr.Size, md5String, nil
}
|
go
|
func getOVAFileInfo(ovafile string, filename string) (int64, string, error) {
of, err := NewOVAFile(ovafile)
if err != nil {
return 0, "", err
}
hdr, err := of.Find(filename)
if err != nil {
return 0, "", err
}
hash := md5.New()
_, err = io.Copy(hash, of)
if err != nil {
return 0, "", err
}
md5String := hex.EncodeToString(hash.Sum(nil)[:16])
return hdr.Size, md5String, nil
}
|
[
"func",
"getOVAFileInfo",
"(",
"ovafile",
"string",
",",
"filename",
"string",
")",
"(",
"int64",
",",
"string",
",",
"error",
")",
"{",
"of",
",",
"err",
":=",
"NewOVAFile",
"(",
"ovafile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"hdr",
",",
"err",
":=",
"of",
".",
"Find",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"hash",
":=",
"md5",
".",
"New",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"hash",
",",
"of",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"md5String",
":=",
"hex",
".",
"EncodeToString",
"(",
"hash",
".",
"Sum",
"(",
"nil",
")",
"[",
":",
"16",
"]",
")",
"\n",
"return",
"hdr",
".",
"Size",
",",
"md5String",
",",
"nil",
"\n",
"}"
] |
// getOVAFileInfo opens an OVA, finds the file entry, and returns both the size and md5 checksum
|
[
"getOVAFileInfo",
"opens",
"an",
"OVA",
"finds",
"the",
"file",
"entry",
"and",
"returns",
"both",
"the",
"size",
"and",
"md5",
"checksum"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/govc/library/ova.go#L128-L147
|
train
|
vmware/govmomi
|
govc/library/ova.go
|
uploadFile
|
func uploadFile(ctx context.Context, m *library.Manager, sessionID string, ovafile string, filename string) error {
var updateFileInfo library.UpdateFile
fmt.Printf("Uploading %s from %s\n", filename, ovafile)
size, md5String, _ := getOVAFileInfo(ovafile, filename)
// Get the URI for the file upload
updateFileInfo.Name = filename
updateFileInfo.Size = &size
updateFileInfo.SourceType = "PUSH"
updateFileInfo.Checksum = &library.Checksum{
Algorithm: "MD5",
Checksum: md5String,
}
addFileInfo, err := m.AddLibraryItemFile(ctx, sessionID, updateFileInfo)
if err != nil {
return err
}
of, err := NewOVAFile(ovafile)
if err != nil {
return err
}
defer of.Close()
// Setup to point to the OVA file to be transferred
_, err = of.Find(filename)
if err != nil {
return err
}
req, err := http.NewRequest("PUT", addFileInfo.UploadEndpoint.URI, of)
if err != nil {
return err
}
req.Header.Set("vmware-api-session-id", sessionID)
return m.Do(ctx, req, nil)
}
|
go
|
func uploadFile(ctx context.Context, m *library.Manager, sessionID string, ovafile string, filename string) error {
var updateFileInfo library.UpdateFile
fmt.Printf("Uploading %s from %s\n", filename, ovafile)
size, md5String, _ := getOVAFileInfo(ovafile, filename)
// Get the URI for the file upload
updateFileInfo.Name = filename
updateFileInfo.Size = &size
updateFileInfo.SourceType = "PUSH"
updateFileInfo.Checksum = &library.Checksum{
Algorithm: "MD5",
Checksum: md5String,
}
addFileInfo, err := m.AddLibraryItemFile(ctx, sessionID, updateFileInfo)
if err != nil {
return err
}
of, err := NewOVAFile(ovafile)
if err != nil {
return err
}
defer of.Close()
// Setup to point to the OVA file to be transferred
_, err = of.Find(filename)
if err != nil {
return err
}
req, err := http.NewRequest("PUT", addFileInfo.UploadEndpoint.URI, of)
if err != nil {
return err
}
req.Header.Set("vmware-api-session-id", sessionID)
return m.Do(ctx, req, nil)
}
|
[
"func",
"uploadFile",
"(",
"ctx",
"context",
".",
"Context",
",",
"m",
"*",
"library",
".",
"Manager",
",",
"sessionID",
"string",
",",
"ovafile",
"string",
",",
"filename",
"string",
")",
"error",
"{",
"var",
"updateFileInfo",
"library",
".",
"UpdateFile",
"\n",
"fmt",
".",
"Printf",
"(",
"\"Uploading %s from %s\\n\"",
",",
"\\n",
",",
"filename",
")",
"\n",
"ovafile",
"\n",
"size",
",",
"md5String",
",",
"_",
":=",
"getOVAFileInfo",
"(",
"ovafile",
",",
"filename",
")",
"\n",
"updateFileInfo",
".",
"Name",
"=",
"filename",
"\n",
"updateFileInfo",
".",
"Size",
"=",
"&",
"size",
"\n",
"updateFileInfo",
".",
"SourceType",
"=",
"\"PUSH\"",
"\n",
"updateFileInfo",
".",
"Checksum",
"=",
"&",
"library",
".",
"Checksum",
"{",
"Algorithm",
":",
"\"MD5\"",
",",
"Checksum",
":",
"md5String",
",",
"}",
"\n",
"addFileInfo",
",",
"err",
":=",
"m",
".",
"AddLibraryItemFile",
"(",
"ctx",
",",
"sessionID",
",",
"updateFileInfo",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"of",
",",
"err",
":=",
"NewOVAFile",
"(",
"ovafile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"of",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"of",
".",
"Find",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"PUT\"",
",",
"addFileInfo",
".",
"UploadEndpoint",
".",
"URI",
",",
"of",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"vmware-api-session-id\"",
",",
"sessionID",
")",
"\n",
"}"
] |
// uploadFile will upload a single file from an OVA using the sessionID provided
|
[
"uploadFile",
"will",
"upload",
"a",
"single",
"file",
"from",
"an",
"OVA",
"using",
"the",
"sessionID",
"provided"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/govc/library/ova.go#L150-L190
|
train
|
vmware/govmomi
|
simulator/folder.go
|
hostsWithDatastore
|
func hostsWithDatastore(hosts []types.ManagedObjectReference, path string) []types.ManagedObjectReference {
attached := hosts[:0]
var p object.DatastorePath
p.FromString(path)
for _, host := range hosts {
h := Map.Get(host).(*HostSystem)
if Map.FindByName(p.Datastore, h.Datastore) != nil {
attached = append(attached, host)
}
}
return attached
}
|
go
|
func hostsWithDatastore(hosts []types.ManagedObjectReference, path string) []types.ManagedObjectReference {
attached := hosts[:0]
var p object.DatastorePath
p.FromString(path)
for _, host := range hosts {
h := Map.Get(host).(*HostSystem)
if Map.FindByName(p.Datastore, h.Datastore) != nil {
attached = append(attached, host)
}
}
return attached
}
|
[
"func",
"hostsWithDatastore",
"(",
"hosts",
"[",
"]",
"types",
".",
"ManagedObjectReference",
",",
"path",
"string",
")",
"[",
"]",
"types",
".",
"ManagedObjectReference",
"{",
"attached",
":=",
"hosts",
"[",
":",
"0",
"]",
"\n",
"var",
"p",
"object",
".",
"DatastorePath",
"\n",
"p",
".",
"FromString",
"(",
"path",
")",
"\n",
"for",
"_",
",",
"host",
":=",
"range",
"hosts",
"{",
"h",
":=",
"Map",
".",
"Get",
"(",
"host",
")",
".",
"(",
"*",
"HostSystem",
")",
"\n",
"if",
"Map",
".",
"FindByName",
"(",
"p",
".",
"Datastore",
",",
"h",
".",
"Datastore",
")",
"!=",
"nil",
"{",
"attached",
"=",
"append",
"(",
"attached",
",",
"host",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"attached",
"\n",
"}"
] |
// hostsWithDatastore returns hosts that have access to the given datastore path
|
[
"hostsWithDatastore",
"returns",
"hosts",
"that",
"have",
"access",
"to",
"the",
"given",
"datastore",
"path"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/folder.go#L260-L273
|
train
|
vmware/govmomi
|
ovf/env.go
|
Marshal
|
func (e Env) Marshal() (string, error) {
x, err := xml.Marshal(e)
if err != nil {
return "", err
}
return fmt.Sprintf("%s%s", xml.Header, x), nil
}
|
go
|
func (e Env) Marshal() (string, error) {
x, err := xml.Marshal(e)
if err != nil {
return "", err
}
return fmt.Sprintf("%s%s", xml.Header, x), nil
}
|
[
"func",
"(",
"e",
"Env",
")",
"Marshal",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"x",
",",
"err",
":=",
"xml",
".",
"Marshal",
"(",
"e",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s%s\"",
",",
"xml",
".",
"Header",
",",
"x",
")",
",",
"nil",
"\n",
"}"
] |
// Marshal marshals Env to xml by using xml.Marshal.
|
[
"Marshal",
"marshals",
"Env",
"to",
"xml",
"by",
"using",
"xml",
".",
"Marshal",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/ovf/env.go#L72-L79
|
train
|
vmware/govmomi
|
ovf/env.go
|
MarshalManual
|
func (e Env) MarshalManual() string {
var buffer bytes.Buffer
buffer.WriteString(xml.Header)
buffer.WriteString(fmt.Sprintf(ovfEnvHeader, e.EsxID))
buffer.WriteString(fmt.Sprintf(ovfEnvPlatformSection, e.Platform.Kind, e.Platform.Version, e.Platform.Vendor, e.Platform.Locale))
buffer.WriteString(fmt.Sprint(ovfEnvPropertyHeader))
for _, p := range e.Property.Properties {
buffer.WriteString(fmt.Sprintf(ovfEnvPropertyEntry, p.Key, p.Value))
}
buffer.WriteString(fmt.Sprint(ovfEnvPropertyFooter))
buffer.WriteString(fmt.Sprint(ovfEnvFooter))
return buffer.String()
}
|
go
|
func (e Env) MarshalManual() string {
var buffer bytes.Buffer
buffer.WriteString(xml.Header)
buffer.WriteString(fmt.Sprintf(ovfEnvHeader, e.EsxID))
buffer.WriteString(fmt.Sprintf(ovfEnvPlatformSection, e.Platform.Kind, e.Platform.Version, e.Platform.Vendor, e.Platform.Locale))
buffer.WriteString(fmt.Sprint(ovfEnvPropertyHeader))
for _, p := range e.Property.Properties {
buffer.WriteString(fmt.Sprintf(ovfEnvPropertyEntry, p.Key, p.Value))
}
buffer.WriteString(fmt.Sprint(ovfEnvPropertyFooter))
buffer.WriteString(fmt.Sprint(ovfEnvFooter))
return buffer.String()
}
|
[
"func",
"(",
"e",
"Env",
")",
"MarshalManual",
"(",
")",
"string",
"{",
"var",
"buffer",
"bytes",
".",
"Buffer",
"\n",
"buffer",
".",
"WriteString",
"(",
"xml",
".",
"Header",
")",
"\n",
"buffer",
".",
"WriteString",
"(",
"fmt",
".",
"Sprintf",
"(",
"ovfEnvHeader",
",",
"e",
".",
"EsxID",
")",
")",
"\n",
"buffer",
".",
"WriteString",
"(",
"fmt",
".",
"Sprintf",
"(",
"ovfEnvPlatformSection",
",",
"e",
".",
"Platform",
".",
"Kind",
",",
"e",
".",
"Platform",
".",
"Version",
",",
"e",
".",
"Platform",
".",
"Vendor",
",",
"e",
".",
"Platform",
".",
"Locale",
")",
")",
"\n",
"buffer",
".",
"WriteString",
"(",
"fmt",
".",
"Sprint",
"(",
"ovfEnvPropertyHeader",
")",
")",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"e",
".",
"Property",
".",
"Properties",
"{",
"buffer",
".",
"WriteString",
"(",
"fmt",
".",
"Sprintf",
"(",
"ovfEnvPropertyEntry",
",",
"p",
".",
"Key",
",",
"p",
".",
"Value",
")",
")",
"\n",
"}",
"\n",
"buffer",
".",
"WriteString",
"(",
"fmt",
".",
"Sprint",
"(",
"ovfEnvPropertyFooter",
")",
")",
"\n",
"buffer",
".",
"WriteString",
"(",
"fmt",
".",
"Sprint",
"(",
"ovfEnvFooter",
")",
")",
"\n",
"return",
"buffer",
".",
"String",
"(",
")",
"\n",
"}"
] |
// MarshalManual manually marshals Env to xml suitable for a vApp guest.
// It exists to overcome the lack of expressiveness in Go's XML namespaces.
|
[
"MarshalManual",
"manually",
"marshals",
"Env",
"to",
"xml",
"suitable",
"for",
"a",
"vApp",
"guest",
".",
"It",
"exists",
"to",
"overcome",
"the",
"lack",
"of",
"expressiveness",
"in",
"Go",
"s",
"XML",
"namespaces",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/ovf/env.go#L83-L99
|
train
|
vmware/govmomi
|
vim25/xml/read.go
|
DecodeElement
|
func (d *Decoder) DecodeElement(v interface{}, start *StartElement) error {
val := reflect.ValueOf(v)
if val.Kind() != reflect.Ptr {
return errors.New("non-pointer passed to Unmarshal")
}
return d.unmarshal(val.Elem(), start)
}
|
go
|
func (d *Decoder) DecodeElement(v interface{}, start *StartElement) error {
val := reflect.ValueOf(v)
if val.Kind() != reflect.Ptr {
return errors.New("non-pointer passed to Unmarshal")
}
return d.unmarshal(val.Elem(), start)
}
|
[
"func",
"(",
"d",
"*",
"Decoder",
")",
"DecodeElement",
"(",
"v",
"interface",
"{",
"}",
",",
"start",
"*",
"StartElement",
")",
"error",
"{",
"val",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
"\n",
"if",
"val",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"{",
"return",
"errors",
".",
"New",
"(",
"\"non-pointer passed to Unmarshal\"",
")",
"\n",
"}",
"\n",
"return",
"d",
".",
"unmarshal",
"(",
"val",
".",
"Elem",
"(",
")",
",",
"start",
")",
"\n",
"}"
] |
// DecodeElement works like xml.Unmarshal except that it takes
// a pointer to the start XML element to decode into v.
// It is useful when a client reads some raw XML tokens itself
// but also wants to defer to Unmarshal for some elements.
|
[
"DecodeElement",
"works",
"like",
"xml",
".",
"Unmarshal",
"except",
"that",
"it",
"takes",
"a",
"pointer",
"to",
"the",
"start",
"XML",
"element",
"to",
"decode",
"into",
"v",
".",
"It",
"is",
"useful",
"when",
"a",
"client",
"reads",
"some",
"raw",
"XML",
"tokens",
"itself",
"but",
"also",
"wants",
"to",
"defer",
"to",
"Unmarshal",
"for",
"some",
"elements",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/xml/read.go#L128-L134
|
train
|
vmware/govmomi
|
vim25/xml/read.go
|
receiverType
|
func receiverType(val interface{}) string {
t := reflect.TypeOf(val)
if t.Name() != "" {
return t.String()
}
return "(" + t.String() + ")"
}
|
go
|
func receiverType(val interface{}) string {
t := reflect.TypeOf(val)
if t.Name() != "" {
return t.String()
}
return "(" + t.String() + ")"
}
|
[
"func",
"receiverType",
"(",
"val",
"interface",
"{",
"}",
")",
"string",
"{",
"t",
":=",
"reflect",
".",
"TypeOf",
"(",
"val",
")",
"\n",
"if",
"t",
".",
"Name",
"(",
")",
"!=",
"\"\"",
"{",
"return",
"t",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"return",
"\"(\"",
"+",
"t",
".",
"String",
"(",
")",
"+",
"\")\"",
"\n",
"}"
] |
// receiverType returns the receiver type to use in an expression like "%s.MethodName".
|
[
"receiverType",
"returns",
"the",
"receiver",
"type",
"to",
"use",
"in",
"an",
"expression",
"like",
"%s",
".",
"MethodName",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/xml/read.go#L173-L179
|
train
|
vmware/govmomi
|
vim25/xml/read.go
|
typeForElement
|
func (p *Decoder) typeForElement(val reflect.Value, start *StartElement) reflect.Type {
t := ""
for i, a := range start.Attr {
if a.Name == xmlSchemaInstance || a.Name == xsiType {
t = a.Value
// HACK: ensure xsi:type is last in the list to avoid using that value for
// a "type" attribute, such as ManagedObjectReference.Type for example.
// Note that xsi:type is already the last attribute in VC/ESX responses.
// This is only an issue with govmomi simulator generated responses.
// Proper fix will require finding a few needles in this xml package haystack.
// Note: govmomi uses xmlSchemaInstance, other clients (e.g. rbvmomi) use xsiType.
// They are the same thing to XML parsers, but not to this hack here.
x := len(start.Attr) - 1
if i != x {
start.Attr[i] = start.Attr[x]
start.Attr[x] = a
}
break
}
}
if t == "" {
// No type attribute; fall back to looking up type by interface name.
t = val.Type().Name()
}
// Maybe the type is a basic xsd:* type.
typ := stringToType(t)
if typ != nil {
return typ
}
// Maybe the type is a custom type.
if p.TypeFunc != nil {
if typ, ok := p.TypeFunc(t); ok {
return typ
}
}
return nil
}
|
go
|
func (p *Decoder) typeForElement(val reflect.Value, start *StartElement) reflect.Type {
t := ""
for i, a := range start.Attr {
if a.Name == xmlSchemaInstance || a.Name == xsiType {
t = a.Value
// HACK: ensure xsi:type is last in the list to avoid using that value for
// a "type" attribute, such as ManagedObjectReference.Type for example.
// Note that xsi:type is already the last attribute in VC/ESX responses.
// This is only an issue with govmomi simulator generated responses.
// Proper fix will require finding a few needles in this xml package haystack.
// Note: govmomi uses xmlSchemaInstance, other clients (e.g. rbvmomi) use xsiType.
// They are the same thing to XML parsers, but not to this hack here.
x := len(start.Attr) - 1
if i != x {
start.Attr[i] = start.Attr[x]
start.Attr[x] = a
}
break
}
}
if t == "" {
// No type attribute; fall back to looking up type by interface name.
t = val.Type().Name()
}
// Maybe the type is a basic xsd:* type.
typ := stringToType(t)
if typ != nil {
return typ
}
// Maybe the type is a custom type.
if p.TypeFunc != nil {
if typ, ok := p.TypeFunc(t); ok {
return typ
}
}
return nil
}
|
[
"func",
"(",
"p",
"*",
"Decoder",
")",
"typeForElement",
"(",
"val",
"reflect",
".",
"Value",
",",
"start",
"*",
"StartElement",
")",
"reflect",
".",
"Type",
"{",
"t",
":=",
"\"\"",
"\n",
"for",
"i",
",",
"a",
":=",
"range",
"start",
".",
"Attr",
"{",
"if",
"a",
".",
"Name",
"==",
"xmlSchemaInstance",
"||",
"a",
".",
"Name",
"==",
"xsiType",
"{",
"t",
"=",
"a",
".",
"Value",
"\n",
"x",
":=",
"len",
"(",
"start",
".",
"Attr",
")",
"-",
"1",
"\n",
"if",
"i",
"!=",
"x",
"{",
"start",
".",
"Attr",
"[",
"i",
"]",
"=",
"start",
".",
"Attr",
"[",
"x",
"]",
"\n",
"start",
".",
"Attr",
"[",
"x",
"]",
"=",
"a",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"t",
"==",
"\"\"",
"{",
"t",
"=",
"val",
".",
"Type",
"(",
")",
".",
"Name",
"(",
")",
"\n",
"}",
"\n",
"typ",
":=",
"stringToType",
"(",
"t",
")",
"\n",
"if",
"typ",
"!=",
"nil",
"{",
"return",
"typ",
"\n",
"}",
"\n",
"if",
"p",
".",
"TypeFunc",
"!=",
"nil",
"{",
"if",
"typ",
",",
"ok",
":=",
"p",
".",
"TypeFunc",
"(",
"t",
")",
";",
"ok",
"{",
"return",
"typ",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Find reflect.Type for an element's type attribute.
|
[
"Find",
"reflect",
".",
"Type",
"for",
"an",
"element",
"s",
"type",
"attribute",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/xml/read.go#L272-L312
|
train
|
vmware/govmomi
|
vim25/xml/read.go
|
unmarshalPath
|
func (p *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement) (consumed bool, err error) {
recurse := false
Loop:
for i := range tinfo.fields {
finfo := &tinfo.fields[i]
if finfo.flags&fElement == 0 || len(finfo.parents) < len(parents) || finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
continue
}
for j := range parents {
if parents[j] != finfo.parents[j] {
continue Loop
}
}
if len(finfo.parents) == len(parents) && finfo.name == start.Name.Local {
// It's a perfect match, unmarshal the field.
return true, p.unmarshal(finfo.value(sv), start)
}
if len(finfo.parents) > len(parents) && finfo.parents[len(parents)] == start.Name.Local {
// It's a prefix for the field. Break and recurse
// since it's not ok for one field path to be itself
// the prefix for another field path.
recurse = true
// We can reuse the same slice as long as we
// don't try to append to it.
parents = finfo.parents[:len(parents)+1]
break
}
}
if !recurse {
// We have no business with this element.
return false, nil
}
// The element is not a perfect match for any field, but one
// or more fields have the path to this element as a parent
// prefix. Recurse and attempt to match these.
for {
var tok Token
tok, err = p.Token()
if err != nil {
return true, err
}
switch t := tok.(type) {
case StartElement:
consumed2, err := p.unmarshalPath(tinfo, sv, parents, &t)
if err != nil {
return true, err
}
if !consumed2 {
if err := p.Skip(); err != nil {
return true, err
}
}
case EndElement:
return true, nil
}
}
}
|
go
|
func (p *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement) (consumed bool, err error) {
recurse := false
Loop:
for i := range tinfo.fields {
finfo := &tinfo.fields[i]
if finfo.flags&fElement == 0 || len(finfo.parents) < len(parents) || finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
continue
}
for j := range parents {
if parents[j] != finfo.parents[j] {
continue Loop
}
}
if len(finfo.parents) == len(parents) && finfo.name == start.Name.Local {
// It's a perfect match, unmarshal the field.
return true, p.unmarshal(finfo.value(sv), start)
}
if len(finfo.parents) > len(parents) && finfo.parents[len(parents)] == start.Name.Local {
// It's a prefix for the field. Break and recurse
// since it's not ok for one field path to be itself
// the prefix for another field path.
recurse = true
// We can reuse the same slice as long as we
// don't try to append to it.
parents = finfo.parents[:len(parents)+1]
break
}
}
if !recurse {
// We have no business with this element.
return false, nil
}
// The element is not a perfect match for any field, but one
// or more fields have the path to this element as a parent
// prefix. Recurse and attempt to match these.
for {
var tok Token
tok, err = p.Token()
if err != nil {
return true, err
}
switch t := tok.(type) {
case StartElement:
consumed2, err := p.unmarshalPath(tinfo, sv, parents, &t)
if err != nil {
return true, err
}
if !consumed2 {
if err := p.Skip(); err != nil {
return true, err
}
}
case EndElement:
return true, nil
}
}
}
|
[
"func",
"(",
"p",
"*",
"Decoder",
")",
"unmarshalPath",
"(",
"tinfo",
"*",
"typeInfo",
",",
"sv",
"reflect",
".",
"Value",
",",
"parents",
"[",
"]",
"string",
",",
"start",
"*",
"StartElement",
")",
"(",
"consumed",
"bool",
",",
"err",
"error",
")",
"{",
"recurse",
":=",
"false",
"\n",
"Loop",
":",
"for",
"i",
":=",
"range",
"tinfo",
".",
"fields",
"{",
"finfo",
":=",
"&",
"tinfo",
".",
"fields",
"[",
"i",
"]",
"\n",
"if",
"finfo",
".",
"flags",
"&",
"fElement",
"==",
"0",
"||",
"len",
"(",
"finfo",
".",
"parents",
")",
"<",
"len",
"(",
"parents",
")",
"||",
"finfo",
".",
"xmlns",
"!=",
"\"\"",
"&&",
"finfo",
".",
"xmlns",
"!=",
"start",
".",
"Name",
".",
"Space",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"j",
":=",
"range",
"parents",
"{",
"if",
"parents",
"[",
"j",
"]",
"!=",
"finfo",
".",
"parents",
"[",
"j",
"]",
"{",
"continue",
"Loop",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"finfo",
".",
"parents",
")",
"==",
"len",
"(",
"parents",
")",
"&&",
"finfo",
".",
"name",
"==",
"start",
".",
"Name",
".",
"Local",
"{",
"return",
"true",
",",
"p",
".",
"unmarshal",
"(",
"finfo",
".",
"value",
"(",
"sv",
")",
",",
"start",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"finfo",
".",
"parents",
")",
">",
"len",
"(",
"parents",
")",
"&&",
"finfo",
".",
"parents",
"[",
"len",
"(",
"parents",
")",
"]",
"==",
"start",
".",
"Name",
".",
"Local",
"{",
"recurse",
"=",
"true",
"\n",
"parents",
"=",
"finfo",
".",
"parents",
"[",
":",
"len",
"(",
"parents",
")",
"+",
"1",
"]",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"recurse",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"for",
"{",
"var",
"tok",
"Token",
"\n",
"tok",
",",
"err",
"=",
"p",
".",
"Token",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"true",
",",
"err",
"\n",
"}",
"\n",
"switch",
"t",
":=",
"tok",
".",
"(",
"type",
")",
"{",
"case",
"StartElement",
":",
"consumed2",
",",
"err",
":=",
"p",
".",
"unmarshalPath",
"(",
"tinfo",
",",
"sv",
",",
"parents",
",",
"&",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"true",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"consumed2",
"{",
"if",
"err",
":=",
"p",
".",
"Skip",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"true",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"EndElement",
":",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// unmarshalPath walks down an XML structure looking for wanted
// paths, and calls unmarshal on them.
// The consumed result tells whether XML elements have been consumed
// from the Decoder until start's matching end element, or if it's
// still untouched because start is uninteresting for sv's fields.
|
[
"unmarshalPath",
"walks",
"down",
"an",
"XML",
"structure",
"looking",
"for",
"wanted",
"paths",
"and",
"calls",
"unmarshal",
"on",
"them",
".",
"The",
"consumed",
"result",
"tells",
"whether",
"XML",
"elements",
"have",
"been",
"consumed",
"from",
"the",
"Decoder",
"until",
"start",
"s",
"matching",
"end",
"element",
"or",
"if",
"it",
"s",
"still",
"untouched",
"because",
"start",
"is",
"uninteresting",
"for",
"sv",
"s",
"fields",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/xml/read.go#L701-L758
|
train
|
vmware/govmomi
|
vim25/xml/read.go
|
Skip
|
func (d *Decoder) Skip() error {
for {
tok, err := d.Token()
if err != nil {
return err
}
switch tok.(type) {
case StartElement:
if err := d.Skip(); err != nil {
return err
}
case EndElement:
return nil
}
}
}
|
go
|
func (d *Decoder) Skip() error {
for {
tok, err := d.Token()
if err != nil {
return err
}
switch tok.(type) {
case StartElement:
if err := d.Skip(); err != nil {
return err
}
case EndElement:
return nil
}
}
}
|
[
"func",
"(",
"d",
"*",
"Decoder",
")",
"Skip",
"(",
")",
"error",
"{",
"for",
"{",
"tok",
",",
"err",
":=",
"d",
".",
"Token",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"switch",
"tok",
".",
"(",
"type",
")",
"{",
"case",
"StartElement",
":",
"if",
"err",
":=",
"d",
".",
"Skip",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"case",
"EndElement",
":",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Skip reads tokens until it has consumed the end element
// matching the most recent start element already consumed.
// It recurs if it encounters a start element, so it can be used to
// skip nested structures.
// It returns nil if it finds an end element matching the start
// element; otherwise it returns an error describing the problem.
|
[
"Skip",
"reads",
"tokens",
"until",
"it",
"has",
"consumed",
"the",
"end",
"element",
"matching",
"the",
"most",
"recent",
"start",
"element",
"already",
"consumed",
".",
"It",
"recurs",
"if",
"it",
"encounters",
"a",
"start",
"element",
"so",
"it",
"can",
"be",
"used",
"to",
"skip",
"nested",
"structures",
".",
"It",
"returns",
"nil",
"if",
"it",
"finds",
"an",
"end",
"element",
"matching",
"the",
"start",
"element",
";",
"otherwise",
"it",
"returns",
"an",
"error",
"describing",
"the",
"problem",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vim25/xml/read.go#L766-L781
|
train
|
vmware/govmomi
|
vapi/library/library_item_updatesession_file.go
|
AddLibraryItemFile
|
func (c *Manager) AddLibraryItemFile(ctx context.Context, sessionID string, updateFile UpdateFile) (*UpdateFileInfo, error) {
url := internal.URL(c, internal.LibraryItemUpdateSessionFile).WithID(sessionID).WithAction("add")
spec := struct {
FileSpec UpdateFile `json:"file_spec"`
}{updateFile}
var res UpdateFileInfo
return &res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
}
|
go
|
func (c *Manager) AddLibraryItemFile(ctx context.Context, sessionID string, updateFile UpdateFile) (*UpdateFileInfo, error) {
url := internal.URL(c, internal.LibraryItemUpdateSessionFile).WithID(sessionID).WithAction("add")
spec := struct {
FileSpec UpdateFile `json:"file_spec"`
}{updateFile}
var res UpdateFileInfo
return &res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"AddLibraryItemFile",
"(",
"ctx",
"context",
".",
"Context",
",",
"sessionID",
"string",
",",
"updateFile",
"UpdateFile",
")",
"(",
"*",
"UpdateFileInfo",
",",
"error",
")",
"{",
"url",
":=",
"internal",
".",
"URL",
"(",
"c",
",",
"internal",
".",
"LibraryItemUpdateSessionFile",
")",
".",
"WithID",
"(",
"sessionID",
")",
".",
"WithAction",
"(",
"\"add\"",
")",
"\n",
"spec",
":=",
"struct",
"{",
"FileSpec",
"UpdateFile",
"`json:\"file_spec\"`",
"\n",
"}",
"{",
"updateFile",
"}",
"\n",
"var",
"res",
"UpdateFileInfo",
"\n",
"return",
"&",
"res",
",",
"c",
".",
"Do",
"(",
"ctx",
",",
"url",
".",
"Request",
"(",
"http",
".",
"MethodPost",
",",
"spec",
")",
",",
"&",
"res",
")",
"\n",
"}"
] |
// AddLibraryItemFile adds a file
|
[
"AddLibraryItemFile",
"adds",
"a",
"file"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/library/library_item_updatesession_file.go#L59-L66
|
train
|
vmware/govmomi
|
vapi/library/library_item_updatesession_file.go
|
AddLibraryItemFileFromURI
|
func (c *Manager) AddLibraryItemFileFromURI(
ctx context.Context,
sessionID, fileName, uri string) (*UpdateFileInfo, error) {
n, fingerprint, err := GetContentLengthAndFingerprint(ctx, uri)
if err != nil {
return nil, err
}
info, err := c.AddLibraryItemFile(ctx, sessionID, UpdateFile{
Name: fileName,
SourceType: "PULL",
Size: &n,
SourceEndpoint: &SourceEndpoint{
URI: uri,
SSLCertificateThumbprint: fingerprint,
},
})
if err != nil {
return nil, err
}
return info, c.CompleteLibraryItemUpdateSession(ctx, sessionID)
}
|
go
|
func (c *Manager) AddLibraryItemFileFromURI(
ctx context.Context,
sessionID, fileName, uri string) (*UpdateFileInfo, error) {
n, fingerprint, err := GetContentLengthAndFingerprint(ctx, uri)
if err != nil {
return nil, err
}
info, err := c.AddLibraryItemFile(ctx, sessionID, UpdateFile{
Name: fileName,
SourceType: "PULL",
Size: &n,
SourceEndpoint: &SourceEndpoint{
URI: uri,
SSLCertificateThumbprint: fingerprint,
},
})
if err != nil {
return nil, err
}
return info, c.CompleteLibraryItemUpdateSession(ctx, sessionID)
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"AddLibraryItemFileFromURI",
"(",
"ctx",
"context",
".",
"Context",
",",
"sessionID",
",",
"fileName",
",",
"uri",
"string",
")",
"(",
"*",
"UpdateFileInfo",
",",
"error",
")",
"{",
"n",
",",
"fingerprint",
",",
"err",
":=",
"GetContentLengthAndFingerprint",
"(",
"ctx",
",",
"uri",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"info",
",",
"err",
":=",
"c",
".",
"AddLibraryItemFile",
"(",
"ctx",
",",
"sessionID",
",",
"UpdateFile",
"{",
"Name",
":",
"fileName",
",",
"SourceType",
":",
"\"PULL\"",
",",
"Size",
":",
"&",
"n",
",",
"SourceEndpoint",
":",
"&",
"SourceEndpoint",
"{",
"URI",
":",
"uri",
",",
"SSLCertificateThumbprint",
":",
"fingerprint",
",",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"info",
",",
"c",
".",
"CompleteLibraryItemUpdateSession",
"(",
"ctx",
",",
"sessionID",
")",
"\n",
"}"
] |
// AddLibraryItemFileFromURI adds a file from a remote URI.
|
[
"AddLibraryItemFileFromURI",
"adds",
"a",
"file",
"from",
"a",
"remote",
"URI",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/library/library_item_updatesession_file.go#L69-L92
|
train
|
vmware/govmomi
|
vapi/library/library_item_updatesession_file.go
|
GetLibraryItemUpdateSessionFile
|
func (c *Manager) GetLibraryItemUpdateSessionFile(ctx context.Context, sessionID string, fileName string) (*UpdateFileInfo, error) {
url := internal.URL(c, internal.LibraryItemUpdateSessionFile).WithID(sessionID).WithAction("get")
spec := struct {
Name string `json:"file_name"`
}{fileName}
var res UpdateFileInfo
return &res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
}
|
go
|
func (c *Manager) GetLibraryItemUpdateSessionFile(ctx context.Context, sessionID string, fileName string) (*UpdateFileInfo, error) {
url := internal.URL(c, internal.LibraryItemUpdateSessionFile).WithID(sessionID).WithAction("get")
spec := struct {
Name string `json:"file_name"`
}{fileName}
var res UpdateFileInfo
return &res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
}
|
[
"func",
"(",
"c",
"*",
"Manager",
")",
"GetLibraryItemUpdateSessionFile",
"(",
"ctx",
"context",
".",
"Context",
",",
"sessionID",
"string",
",",
"fileName",
"string",
")",
"(",
"*",
"UpdateFileInfo",
",",
"error",
")",
"{",
"url",
":=",
"internal",
".",
"URL",
"(",
"c",
",",
"internal",
".",
"LibraryItemUpdateSessionFile",
")",
".",
"WithID",
"(",
"sessionID",
")",
".",
"WithAction",
"(",
"\"get\"",
")",
"\n",
"spec",
":=",
"struct",
"{",
"Name",
"string",
"`json:\"file_name\"`",
"\n",
"}",
"{",
"fileName",
"}",
"\n",
"var",
"res",
"UpdateFileInfo",
"\n",
"return",
"&",
"res",
",",
"c",
".",
"Do",
"(",
"ctx",
",",
"url",
".",
"Request",
"(",
"http",
".",
"MethodPost",
",",
"spec",
")",
",",
"&",
"res",
")",
"\n",
"}"
] |
// GetLibraryItemUpdateSessionFile retrieves information about a specific file
// that is a part of an update session.
|
[
"GetLibraryItemUpdateSessionFile",
"retrieves",
"information",
"about",
"a",
"specific",
"file",
"that",
"is",
"a",
"part",
"of",
"an",
"update",
"session",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/library/library_item_updatesession_file.go#L96-L103
|
train
|
vmware/govmomi
|
vapi/library/library_item_updatesession_file.go
|
GetContentLengthAndFingerprint
|
func GetContentLengthAndFingerprint(
ctx context.Context, uri string) (int64, string, error) {
resp, err := http.Head(uri)
if err != nil {
return 0, "", err
}
if resp.TLS == nil || len(resp.TLS.PeerCertificates) == 0 {
return resp.ContentLength, "", nil
}
fingerprint := &bytes.Buffer{}
sum := sha1.Sum(resp.TLS.PeerCertificates[0].Raw)
for i, b := range sum {
fmt.Fprintf(fingerprint, "%X", b)
if i < len(sum)-1 {
fmt.Fprint(fingerprint, ":")
}
}
return resp.ContentLength, fingerprint.String(), nil
}
|
go
|
func GetContentLengthAndFingerprint(
ctx context.Context, uri string) (int64, string, error) {
resp, err := http.Head(uri)
if err != nil {
return 0, "", err
}
if resp.TLS == nil || len(resp.TLS.PeerCertificates) == 0 {
return resp.ContentLength, "", nil
}
fingerprint := &bytes.Buffer{}
sum := sha1.Sum(resp.TLS.PeerCertificates[0].Raw)
for i, b := range sum {
fmt.Fprintf(fingerprint, "%X", b)
if i < len(sum)-1 {
fmt.Fprint(fingerprint, ":")
}
}
return resp.ContentLength, fingerprint.String(), nil
}
|
[
"func",
"GetContentLengthAndFingerprint",
"(",
"ctx",
"context",
".",
"Context",
",",
"uri",
"string",
")",
"(",
"int64",
",",
"string",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"http",
".",
"Head",
"(",
"uri",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"resp",
".",
"TLS",
"==",
"nil",
"||",
"len",
"(",
"resp",
".",
"TLS",
".",
"PeerCertificates",
")",
"==",
"0",
"{",
"return",
"resp",
".",
"ContentLength",
",",
"\"\"",
",",
"nil",
"\n",
"}",
"\n",
"fingerprint",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"sum",
":=",
"sha1",
".",
"Sum",
"(",
"resp",
".",
"TLS",
".",
"PeerCertificates",
"[",
"0",
"]",
".",
"Raw",
")",
"\n",
"for",
"i",
",",
"b",
":=",
"range",
"sum",
"{",
"fmt",
".",
"Fprintf",
"(",
"fingerprint",
",",
"\"%X\"",
",",
"b",
")",
"\n",
"if",
"i",
"<",
"len",
"(",
"sum",
")",
"-",
"1",
"{",
"fmt",
".",
"Fprint",
"(",
"fingerprint",
",",
"\":\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"resp",
".",
"ContentLength",
",",
"fingerprint",
".",
"String",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// GetContentLengthAndFingerprint gets the number of bytes returned
// by the URI as well as the SHA1 fingerprint of the peer certificate
// if the URI's scheme is https.
|
[
"GetContentLengthAndFingerprint",
"gets",
"the",
"number",
"of",
"bytes",
"returned",
"by",
"the",
"URI",
"as",
"well",
"as",
"the",
"SHA1",
"fingerprint",
"of",
"the",
"peer",
"certificate",
"if",
"the",
"URI",
"s",
"scheme",
"is",
"https",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/vapi/library/library_item_updatesession_file.go#L108-L126
|
train
|
vmware/govmomi
|
simulator/event_manager.go
|
formatMessage
|
func (m *EventManager) formatMessage(event types.BaseEvent) {
id := reflect.ValueOf(event).Elem().Type().Name()
e := event.GetEvent()
t, ok := m.templates[id]
if !ok {
for _, info := range m.Description.EventInfo {
if info.Key == id {
t = template.Must(template.New(id).Parse(info.FullFormat))
m.templates[id] = t
break
}
}
}
if t != nil {
var buf bytes.Buffer
if err := t.Execute(&buf, event); err != nil {
log.Print(err)
}
e.FullFormattedMessage = buf.String()
}
if logEvents {
log.Printf("[%s] %s", id, e.FullFormattedMessage)
}
}
|
go
|
func (m *EventManager) formatMessage(event types.BaseEvent) {
id := reflect.ValueOf(event).Elem().Type().Name()
e := event.GetEvent()
t, ok := m.templates[id]
if !ok {
for _, info := range m.Description.EventInfo {
if info.Key == id {
t = template.Must(template.New(id).Parse(info.FullFormat))
m.templates[id] = t
break
}
}
}
if t != nil {
var buf bytes.Buffer
if err := t.Execute(&buf, event); err != nil {
log.Print(err)
}
e.FullFormattedMessage = buf.String()
}
if logEvents {
log.Printf("[%s] %s", id, e.FullFormattedMessage)
}
}
|
[
"func",
"(",
"m",
"*",
"EventManager",
")",
"formatMessage",
"(",
"event",
"types",
".",
"BaseEvent",
")",
"{",
"id",
":=",
"reflect",
".",
"ValueOf",
"(",
"event",
")",
".",
"Elem",
"(",
")",
".",
"Type",
"(",
")",
".",
"Name",
"(",
")",
"\n",
"e",
":=",
"event",
".",
"GetEvent",
"(",
")",
"\n",
"t",
",",
"ok",
":=",
"m",
".",
"templates",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"for",
"_",
",",
"info",
":=",
"range",
"m",
".",
"Description",
".",
"EventInfo",
"{",
"if",
"info",
".",
"Key",
"==",
"id",
"{",
"t",
"=",
"template",
".",
"Must",
"(",
"template",
".",
"New",
"(",
"id",
")",
".",
"Parse",
"(",
"info",
".",
"FullFormat",
")",
")",
"\n",
"m",
".",
"templates",
"[",
"id",
"]",
"=",
"t",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"t",
"!=",
"nil",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"if",
"err",
":=",
"t",
".",
"Execute",
"(",
"&",
"buf",
",",
"event",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"err",
")",
"\n",
"}",
"\n",
"e",
".",
"FullFormattedMessage",
"=",
"buf",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"if",
"logEvents",
"{",
"log",
".",
"Printf",
"(",
"\"[%s] %s\"",
",",
"id",
",",
"e",
".",
"FullFormattedMessage",
")",
"\n",
"}",
"\n",
"}"
] |
// formatMessage applies the EventDescriptionEventDetail.FullFormat template to the given event's FullFormattedMessage field.
|
[
"formatMessage",
"applies",
"the",
"EventDescriptionEventDetail",
".",
"FullFormat",
"template",
"to",
"the",
"given",
"event",
"s",
"FullFormattedMessage",
"field",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/event_manager.go#L126-L152
|
train
|
vmware/govmomi
|
simulator/event_manager.go
|
doEntityEventArgument
|
func doEntityEventArgument(event types.BaseEvent, f func(types.ManagedObjectReference, *types.EntityEventArgument) bool) bool {
e := event.GetEvent()
if arg := e.Vm; arg != nil {
if f(arg.Vm, &arg.EntityEventArgument) {
return true
}
}
if arg := e.Host; arg != nil {
if f(arg.Host, &arg.EntityEventArgument) {
return true
}
}
if arg := e.ComputeResource; arg != nil {
if f(arg.ComputeResource, &arg.EntityEventArgument) {
return true
}
}
if arg := e.Ds; arg != nil {
if f(arg.Datastore, &arg.EntityEventArgument) {
return true
}
}
if arg := e.Net; arg != nil {
if f(arg.Network, &arg.EntityEventArgument) {
return true
}
}
if arg := e.Dvs; arg != nil {
if f(arg.Dvs, &arg.EntityEventArgument) {
return true
}
}
if arg := e.Datacenter; arg != nil {
if f(arg.Datacenter, &arg.EntityEventArgument) {
return true
}
}
return false
}
|
go
|
func doEntityEventArgument(event types.BaseEvent, f func(types.ManagedObjectReference, *types.EntityEventArgument) bool) bool {
e := event.GetEvent()
if arg := e.Vm; arg != nil {
if f(arg.Vm, &arg.EntityEventArgument) {
return true
}
}
if arg := e.Host; arg != nil {
if f(arg.Host, &arg.EntityEventArgument) {
return true
}
}
if arg := e.ComputeResource; arg != nil {
if f(arg.ComputeResource, &arg.EntityEventArgument) {
return true
}
}
if arg := e.Ds; arg != nil {
if f(arg.Datastore, &arg.EntityEventArgument) {
return true
}
}
if arg := e.Net; arg != nil {
if f(arg.Network, &arg.EntityEventArgument) {
return true
}
}
if arg := e.Dvs; arg != nil {
if f(arg.Dvs, &arg.EntityEventArgument) {
return true
}
}
if arg := e.Datacenter; arg != nil {
if f(arg.Datacenter, &arg.EntityEventArgument) {
return true
}
}
return false
}
|
[
"func",
"doEntityEventArgument",
"(",
"event",
"types",
".",
"BaseEvent",
",",
"f",
"func",
"(",
"types",
".",
"ManagedObjectReference",
",",
"*",
"types",
".",
"EntityEventArgument",
")",
"bool",
")",
"bool",
"{",
"e",
":=",
"event",
".",
"GetEvent",
"(",
")",
"\n",
"if",
"arg",
":=",
"e",
".",
"Vm",
";",
"arg",
"!=",
"nil",
"{",
"if",
"f",
"(",
"arg",
".",
"Vm",
",",
"&",
"arg",
".",
"EntityEventArgument",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"arg",
":=",
"e",
".",
"Host",
";",
"arg",
"!=",
"nil",
"{",
"if",
"f",
"(",
"arg",
".",
"Host",
",",
"&",
"arg",
".",
"EntityEventArgument",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"arg",
":=",
"e",
".",
"ComputeResource",
";",
"arg",
"!=",
"nil",
"{",
"if",
"f",
"(",
"arg",
".",
"ComputeResource",
",",
"&",
"arg",
".",
"EntityEventArgument",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"arg",
":=",
"e",
".",
"Ds",
";",
"arg",
"!=",
"nil",
"{",
"if",
"f",
"(",
"arg",
".",
"Datastore",
",",
"&",
"arg",
".",
"EntityEventArgument",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"arg",
":=",
"e",
".",
"Net",
";",
"arg",
"!=",
"nil",
"{",
"if",
"f",
"(",
"arg",
".",
"Network",
",",
"&",
"arg",
".",
"EntityEventArgument",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"arg",
":=",
"e",
".",
"Dvs",
";",
"arg",
"!=",
"nil",
"{",
"if",
"f",
"(",
"arg",
".",
"Dvs",
",",
"&",
"arg",
".",
"EntityEventArgument",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"arg",
":=",
"e",
".",
"Datacenter",
";",
"arg",
"!=",
"nil",
"{",
"if",
"f",
"(",
"arg",
".",
"Datacenter",
",",
"&",
"arg",
".",
"EntityEventArgument",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// doEntityEventArgument calls f for each entity argument in the event.
// If f returns true, the iteration stops.
|
[
"doEntityEventArgument",
"calls",
"f",
"for",
"each",
"entity",
"argument",
"in",
"the",
"event",
".",
"If",
"f",
"returns",
"true",
"the",
"iteration",
"stops",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/event_manager.go#L191-L237
|
train
|
vmware/govmomi
|
simulator/event_manager.go
|
eventFilterSelf
|
func eventFilterSelf(event types.BaseEvent, self types.ManagedObjectReference) bool {
return doEntityEventArgument(event, func(ref types.ManagedObjectReference, _ *types.EntityEventArgument) bool {
return self == ref
})
}
|
go
|
func eventFilterSelf(event types.BaseEvent, self types.ManagedObjectReference) bool {
return doEntityEventArgument(event, func(ref types.ManagedObjectReference, _ *types.EntityEventArgument) bool {
return self == ref
})
}
|
[
"func",
"eventFilterSelf",
"(",
"event",
"types",
".",
"BaseEvent",
",",
"self",
"types",
".",
"ManagedObjectReference",
")",
"bool",
"{",
"return",
"doEntityEventArgument",
"(",
"event",
",",
"func",
"(",
"ref",
"types",
".",
"ManagedObjectReference",
",",
"_",
"*",
"types",
".",
"EntityEventArgument",
")",
"bool",
"{",
"return",
"self",
"==",
"ref",
"\n",
"}",
")",
"\n",
"}"
] |
// eventFilterSelf returns true if self is one of the entity arguments in the event.
|
[
"eventFilterSelf",
"returns",
"true",
"if",
"self",
"is",
"one",
"of",
"the",
"entity",
"arguments",
"in",
"the",
"event",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/event_manager.go#L240-L244
|
train
|
vmware/govmomi
|
simulator/event_manager.go
|
eventFilterChildren
|
func eventFilterChildren(event types.BaseEvent, self types.ManagedObjectReference) bool {
return doEntityEventArgument(event, func(ref types.ManagedObjectReference, _ *types.EntityEventArgument) bool {
seen := false
var match func(types.ManagedObjectReference)
match = func(child types.ManagedObjectReference) {
if child == self {
seen = true
return
}
walk(child, match)
}
walk(ref, match)
return seen
})
}
|
go
|
func eventFilterChildren(event types.BaseEvent, self types.ManagedObjectReference) bool {
return doEntityEventArgument(event, func(ref types.ManagedObjectReference, _ *types.EntityEventArgument) bool {
seen := false
var match func(types.ManagedObjectReference)
match = func(child types.ManagedObjectReference) {
if child == self {
seen = true
return
}
walk(child, match)
}
walk(ref, match)
return seen
})
}
|
[
"func",
"eventFilterChildren",
"(",
"event",
"types",
".",
"BaseEvent",
",",
"self",
"types",
".",
"ManagedObjectReference",
")",
"bool",
"{",
"return",
"doEntityEventArgument",
"(",
"event",
",",
"func",
"(",
"ref",
"types",
".",
"ManagedObjectReference",
",",
"_",
"*",
"types",
".",
"EntityEventArgument",
")",
"bool",
"{",
"seen",
":=",
"false",
"\n",
"var",
"match",
"func",
"(",
"types",
".",
"ManagedObjectReference",
")",
"\n",
"match",
"=",
"func",
"(",
"child",
"types",
".",
"ManagedObjectReference",
")",
"{",
"if",
"child",
"==",
"self",
"{",
"seen",
"=",
"true",
"\n",
"return",
"\n",
"}",
"\n",
"walk",
"(",
"child",
",",
"match",
")",
"\n",
"}",
"\n",
"walk",
"(",
"ref",
",",
"match",
")",
"\n",
"return",
"seen",
"\n",
"}",
")",
"\n",
"}"
] |
// eventFilterChildren returns true if a child of self is one of the entity arguments in the event.
|
[
"eventFilterChildren",
"returns",
"true",
"if",
"a",
"child",
"of",
"self",
"is",
"one",
"of",
"the",
"entity",
"arguments",
"in",
"the",
"event",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/event_manager.go#L247-L266
|
train
|
vmware/govmomi
|
simulator/event_manager.go
|
entityMatches
|
func (c *EventHistoryCollector) entityMatches(event types.BaseEvent, spec *types.EventFilterSpec) bool {
e := spec.Entity
if e == nil {
return true
}
isRootFolder := c.m.root == e.Entity
switch e.Recursion {
case types.EventFilterSpecRecursionOptionSelf:
return isRootFolder || eventFilterSelf(event, e.Entity)
case types.EventFilterSpecRecursionOptionChildren:
return eventFilterChildren(event, e.Entity)
case types.EventFilterSpecRecursionOptionAll:
if isRootFolder || eventFilterSelf(event, e.Entity) {
return true
}
return eventFilterChildren(event, e.Entity)
}
return false
}
|
go
|
func (c *EventHistoryCollector) entityMatches(event types.BaseEvent, spec *types.EventFilterSpec) bool {
e := spec.Entity
if e == nil {
return true
}
isRootFolder := c.m.root == e.Entity
switch e.Recursion {
case types.EventFilterSpecRecursionOptionSelf:
return isRootFolder || eventFilterSelf(event, e.Entity)
case types.EventFilterSpecRecursionOptionChildren:
return eventFilterChildren(event, e.Entity)
case types.EventFilterSpecRecursionOptionAll:
if isRootFolder || eventFilterSelf(event, e.Entity) {
return true
}
return eventFilterChildren(event, e.Entity)
}
return false
}
|
[
"func",
"(",
"c",
"*",
"EventHistoryCollector",
")",
"entityMatches",
"(",
"event",
"types",
".",
"BaseEvent",
",",
"spec",
"*",
"types",
".",
"EventFilterSpec",
")",
"bool",
"{",
"e",
":=",
"spec",
".",
"Entity",
"\n",
"if",
"e",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n",
"isRootFolder",
":=",
"c",
".",
"m",
".",
"root",
"==",
"e",
".",
"Entity",
"\n",
"switch",
"e",
".",
"Recursion",
"{",
"case",
"types",
".",
"EventFilterSpecRecursionOptionSelf",
":",
"return",
"isRootFolder",
"||",
"eventFilterSelf",
"(",
"event",
",",
"e",
".",
"Entity",
")",
"\n",
"case",
"types",
".",
"EventFilterSpecRecursionOptionChildren",
":",
"return",
"eventFilterChildren",
"(",
"event",
",",
"e",
".",
"Entity",
")",
"\n",
"case",
"types",
".",
"EventFilterSpecRecursionOptionAll",
":",
"if",
"isRootFolder",
"||",
"eventFilterSelf",
"(",
"event",
",",
"e",
".",
"Entity",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"eventFilterChildren",
"(",
"event",
",",
"e",
".",
"Entity",
")",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// entityMatches returns true if the spec Entity filter matches the event.
|
[
"entityMatches",
"returns",
"true",
"if",
"the",
"spec",
"Entity",
"filter",
"matches",
"the",
"event",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/event_manager.go#L269-L290
|
train
|
vmware/govmomi
|
simulator/event_manager.go
|
typeMatches
|
func (c *EventHistoryCollector) typeMatches(event types.BaseEvent, spec *types.EventFilterSpec) bool {
if len(spec.EventTypeId) == 0 {
return true
}
matches := func(name string) bool {
for _, id := range spec.EventTypeId {
if id == name {
return true
}
}
return false
}
kind := reflect.ValueOf(event).Elem().Type()
if matches(kind.Name()) {
return true // concrete type
}
field, ok := kind.FieldByNameFunc(matches)
if ok {
return field.Anonymous // base type (embedded field)
}
return false
}
|
go
|
func (c *EventHistoryCollector) typeMatches(event types.BaseEvent, spec *types.EventFilterSpec) bool {
if len(spec.EventTypeId) == 0 {
return true
}
matches := func(name string) bool {
for _, id := range spec.EventTypeId {
if id == name {
return true
}
}
return false
}
kind := reflect.ValueOf(event).Elem().Type()
if matches(kind.Name()) {
return true // concrete type
}
field, ok := kind.FieldByNameFunc(matches)
if ok {
return field.Anonymous // base type (embedded field)
}
return false
}
|
[
"func",
"(",
"c",
"*",
"EventHistoryCollector",
")",
"typeMatches",
"(",
"event",
"types",
".",
"BaseEvent",
",",
"spec",
"*",
"types",
".",
"EventFilterSpec",
")",
"bool",
"{",
"if",
"len",
"(",
"spec",
".",
"EventTypeId",
")",
"==",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n",
"matches",
":=",
"func",
"(",
"name",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"id",
":=",
"range",
"spec",
".",
"EventTypeId",
"{",
"if",
"id",
"==",
"name",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"kind",
":=",
"reflect",
".",
"ValueOf",
"(",
"event",
")",
".",
"Elem",
"(",
")",
".",
"Type",
"(",
")",
"\n",
"if",
"matches",
"(",
"kind",
".",
"Name",
"(",
")",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"field",
",",
"ok",
":=",
"kind",
".",
"FieldByNameFunc",
"(",
"matches",
")",
"\n",
"if",
"ok",
"{",
"return",
"field",
".",
"Anonymous",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// typeMatches returns true if one of the spec EventTypeId types matches the event.
|
[
"typeMatches",
"returns",
"true",
"if",
"one",
"of",
"the",
"spec",
"EventTypeId",
"types",
"matches",
"the",
"event",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/event_manager.go#L293-L317
|
train
|
vmware/govmomi
|
simulator/event_manager.go
|
eventMatches
|
func (c *EventHistoryCollector) eventMatches(event types.BaseEvent) bool {
spec := c.Filter.(types.EventFilterSpec)
if !c.typeMatches(event, &spec) {
return false
}
// TODO: spec.Time, spec.UserName, etc
return c.entityMatches(event, &spec)
}
|
go
|
func (c *EventHistoryCollector) eventMatches(event types.BaseEvent) bool {
spec := c.Filter.(types.EventFilterSpec)
if !c.typeMatches(event, &spec) {
return false
}
// TODO: spec.Time, spec.UserName, etc
return c.entityMatches(event, &spec)
}
|
[
"func",
"(",
"c",
"*",
"EventHistoryCollector",
")",
"eventMatches",
"(",
"event",
"types",
".",
"BaseEvent",
")",
"bool",
"{",
"spec",
":=",
"c",
".",
"Filter",
".",
"(",
"types",
".",
"EventFilterSpec",
")",
"\n",
"if",
"!",
"c",
".",
"typeMatches",
"(",
"event",
",",
"&",
"spec",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"c",
".",
"entityMatches",
"(",
"event",
",",
"&",
"spec",
")",
"\n",
"}"
] |
// eventMatches returns true one of the filters matches the event.
|
[
"eventMatches",
"returns",
"true",
"one",
"of",
"the",
"filters",
"matches",
"the",
"event",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/event_manager.go#L320-L330
|
train
|
vmware/govmomi
|
simulator/event_manager.go
|
fillPage
|
func (c *EventHistoryCollector) fillPage(size int) {
c.pos = 0
l := c.page.Len()
delta := size - l
if delta < 0 {
// Shrink ring size
c.page = c.page.Unlink(-delta)
return
}
matches := 0
mpage := c.m.page
page := c.page
if delta != 0 {
// Grow ring size
c.page = c.page.Link(ring.New(delta))
}
for i := 0; i < maxPageSize; i++ {
event, ok := mpage.Value.(types.BaseEvent)
mpage = mpage.Prev()
if !ok {
continue
}
if c.eventMatches(event) {
page.Value = event
page = page.Prev()
matches++
if matches == size {
break
}
}
}
}
|
go
|
func (c *EventHistoryCollector) fillPage(size int) {
c.pos = 0
l := c.page.Len()
delta := size - l
if delta < 0 {
// Shrink ring size
c.page = c.page.Unlink(-delta)
return
}
matches := 0
mpage := c.m.page
page := c.page
if delta != 0 {
// Grow ring size
c.page = c.page.Link(ring.New(delta))
}
for i := 0; i < maxPageSize; i++ {
event, ok := mpage.Value.(types.BaseEvent)
mpage = mpage.Prev()
if !ok {
continue
}
if c.eventMatches(event) {
page.Value = event
page = page.Prev()
matches++
if matches == size {
break
}
}
}
}
|
[
"func",
"(",
"c",
"*",
"EventHistoryCollector",
")",
"fillPage",
"(",
"size",
"int",
")",
"{",
"c",
".",
"pos",
"=",
"0",
"\n",
"l",
":=",
"c",
".",
"page",
".",
"Len",
"(",
")",
"\n",
"delta",
":=",
"size",
"-",
"l",
"\n",
"if",
"delta",
"<",
"0",
"{",
"c",
".",
"page",
"=",
"c",
".",
"page",
".",
"Unlink",
"(",
"-",
"delta",
")",
"\n",
"return",
"\n",
"}",
"\n",
"matches",
":=",
"0",
"\n",
"mpage",
":=",
"c",
".",
"m",
".",
"page",
"\n",
"page",
":=",
"c",
".",
"page",
"\n",
"if",
"delta",
"!=",
"0",
"{",
"c",
".",
"page",
"=",
"c",
".",
"page",
".",
"Link",
"(",
"ring",
".",
"New",
"(",
"delta",
")",
")",
"\n",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"maxPageSize",
";",
"i",
"++",
"{",
"event",
",",
"ok",
":=",
"mpage",
".",
"Value",
".",
"(",
"types",
".",
"BaseEvent",
")",
"\n",
"mpage",
"=",
"mpage",
".",
"Prev",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"c",
".",
"eventMatches",
"(",
"event",
")",
"{",
"page",
".",
"Value",
"=",
"event",
"\n",
"page",
"=",
"page",
".",
"Prev",
"(",
")",
"\n",
"matches",
"++",
"\n",
"if",
"matches",
"==",
"size",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// filePage copies the manager's latest events into the collector's page with Filter applied.
|
[
"filePage",
"copies",
"the",
"manager",
"s",
"latest",
"events",
"into",
"the",
"collector",
"s",
"page",
"with",
"Filter",
"applied",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/simulator/event_manager.go#L333-L369
|
train
|
vmware/govmomi
|
object/virtual_disk_manager.go
|
CopyVirtualDisk
|
func (m VirtualDiskManager) CopyVirtualDisk(
ctx context.Context,
sourceName string, sourceDatacenter *Datacenter,
destName string, destDatacenter *Datacenter,
destSpec *types.VirtualDiskSpec, force bool) (*Task, error) {
req := types.CopyVirtualDisk_Task{
This: m.Reference(),
SourceName: sourceName,
DestName: destName,
DestSpec: destSpec,
Force: types.NewBool(force),
}
if sourceDatacenter != nil {
ref := sourceDatacenter.Reference()
req.SourceDatacenter = &ref
}
if destDatacenter != nil {
ref := destDatacenter.Reference()
req.DestDatacenter = &ref
}
res, err := methods.CopyVirtualDisk_Task(ctx, m.c, &req)
if err != nil {
return nil, err
}
return NewTask(m.c, res.Returnval), nil
}
|
go
|
func (m VirtualDiskManager) CopyVirtualDisk(
ctx context.Context,
sourceName string, sourceDatacenter *Datacenter,
destName string, destDatacenter *Datacenter,
destSpec *types.VirtualDiskSpec, force bool) (*Task, error) {
req := types.CopyVirtualDisk_Task{
This: m.Reference(),
SourceName: sourceName,
DestName: destName,
DestSpec: destSpec,
Force: types.NewBool(force),
}
if sourceDatacenter != nil {
ref := sourceDatacenter.Reference()
req.SourceDatacenter = &ref
}
if destDatacenter != nil {
ref := destDatacenter.Reference()
req.DestDatacenter = &ref
}
res, err := methods.CopyVirtualDisk_Task(ctx, m.c, &req)
if err != nil {
return nil, err
}
return NewTask(m.c, res.Returnval), nil
}
|
[
"func",
"(",
"m",
"VirtualDiskManager",
")",
"CopyVirtualDisk",
"(",
"ctx",
"context",
".",
"Context",
",",
"sourceName",
"string",
",",
"sourceDatacenter",
"*",
"Datacenter",
",",
"destName",
"string",
",",
"destDatacenter",
"*",
"Datacenter",
",",
"destSpec",
"*",
"types",
".",
"VirtualDiskSpec",
",",
"force",
"bool",
")",
"(",
"*",
"Task",
",",
"error",
")",
"{",
"req",
":=",
"types",
".",
"CopyVirtualDisk_Task",
"{",
"This",
":",
"m",
".",
"Reference",
"(",
")",
",",
"SourceName",
":",
"sourceName",
",",
"DestName",
":",
"destName",
",",
"DestSpec",
":",
"destSpec",
",",
"Force",
":",
"types",
".",
"NewBool",
"(",
"force",
")",
",",
"}",
"\n",
"if",
"sourceDatacenter",
"!=",
"nil",
"{",
"ref",
":=",
"sourceDatacenter",
".",
"Reference",
"(",
")",
"\n",
"req",
".",
"SourceDatacenter",
"=",
"&",
"ref",
"\n",
"}",
"\n",
"if",
"destDatacenter",
"!=",
"nil",
"{",
"ref",
":=",
"destDatacenter",
".",
"Reference",
"(",
")",
"\n",
"req",
".",
"DestDatacenter",
"=",
"&",
"ref",
"\n",
"}",
"\n",
"res",
",",
"err",
":=",
"methods",
".",
"CopyVirtualDisk_Task",
"(",
"ctx",
",",
"m",
".",
"c",
",",
"&",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewTask",
"(",
"m",
".",
"c",
",",
"res",
".",
"Returnval",
")",
",",
"nil",
"\n",
"}"
] |
// CopyVirtualDisk copies a virtual disk, performing conversions as specified in the spec.
|
[
"CopyVirtualDisk",
"copies",
"a",
"virtual",
"disk",
"performing",
"conversions",
"as",
"specified",
"in",
"the",
"spec",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/object/virtual_disk_manager.go#L40-L70
|
train
|
vmware/govmomi
|
object/virtual_disk_manager.go
|
CreateVirtualDisk
|
func (m VirtualDiskManager) CreateVirtualDisk(
ctx context.Context,
name string, datacenter *Datacenter,
spec types.BaseVirtualDiskSpec) (*Task, error) {
req := types.CreateVirtualDisk_Task{
This: m.Reference(),
Name: name,
Spec: spec,
}
if datacenter != nil {
ref := datacenter.Reference()
req.Datacenter = &ref
}
res, err := methods.CreateVirtualDisk_Task(ctx, m.c, &req)
if err != nil {
return nil, err
}
return NewTask(m.c, res.Returnval), nil
}
|
go
|
func (m VirtualDiskManager) CreateVirtualDisk(
ctx context.Context,
name string, datacenter *Datacenter,
spec types.BaseVirtualDiskSpec) (*Task, error) {
req := types.CreateVirtualDisk_Task{
This: m.Reference(),
Name: name,
Spec: spec,
}
if datacenter != nil {
ref := datacenter.Reference()
req.Datacenter = &ref
}
res, err := methods.CreateVirtualDisk_Task(ctx, m.c, &req)
if err != nil {
return nil, err
}
return NewTask(m.c, res.Returnval), nil
}
|
[
"func",
"(",
"m",
"VirtualDiskManager",
")",
"CreateVirtualDisk",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
",",
"datacenter",
"*",
"Datacenter",
",",
"spec",
"types",
".",
"BaseVirtualDiskSpec",
")",
"(",
"*",
"Task",
",",
"error",
")",
"{",
"req",
":=",
"types",
".",
"CreateVirtualDisk_Task",
"{",
"This",
":",
"m",
".",
"Reference",
"(",
")",
",",
"Name",
":",
"name",
",",
"Spec",
":",
"spec",
",",
"}",
"\n",
"if",
"datacenter",
"!=",
"nil",
"{",
"ref",
":=",
"datacenter",
".",
"Reference",
"(",
")",
"\n",
"req",
".",
"Datacenter",
"=",
"&",
"ref",
"\n",
"}",
"\n",
"res",
",",
"err",
":=",
"methods",
".",
"CreateVirtualDisk_Task",
"(",
"ctx",
",",
"m",
".",
"c",
",",
"&",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewTask",
"(",
"m",
".",
"c",
",",
"res",
".",
"Returnval",
")",
",",
"nil",
"\n",
"}"
] |
// CreateVirtualDisk creates a new virtual disk.
|
[
"CreateVirtualDisk",
"creates",
"a",
"new",
"virtual",
"disk",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/object/virtual_disk_manager.go#L73-L95
|
train
|
vmware/govmomi
|
object/virtual_disk_manager.go
|
ShrinkVirtualDisk
|
func (m VirtualDiskManager) ShrinkVirtualDisk(ctx context.Context, name string, dc *Datacenter, copy *bool) (*Task, error) {
req := types.ShrinkVirtualDisk_Task{
This: m.Reference(),
Name: name,
Copy: copy,
}
if dc != nil {
ref := dc.Reference()
req.Datacenter = &ref
}
res, err := methods.ShrinkVirtualDisk_Task(ctx, m.c, &req)
if err != nil {
return nil, err
}
return NewTask(m.c, res.Returnval), nil
}
|
go
|
func (m VirtualDiskManager) ShrinkVirtualDisk(ctx context.Context, name string, dc *Datacenter, copy *bool) (*Task, error) {
req := types.ShrinkVirtualDisk_Task{
This: m.Reference(),
Name: name,
Copy: copy,
}
if dc != nil {
ref := dc.Reference()
req.Datacenter = &ref
}
res, err := methods.ShrinkVirtualDisk_Task(ctx, m.c, &req)
if err != nil {
return nil, err
}
return NewTask(m.c, res.Returnval), nil
}
|
[
"func",
"(",
"m",
"VirtualDiskManager",
")",
"ShrinkVirtualDisk",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
",",
"dc",
"*",
"Datacenter",
",",
"copy",
"*",
"bool",
")",
"(",
"*",
"Task",
",",
"error",
")",
"{",
"req",
":=",
"types",
".",
"ShrinkVirtualDisk_Task",
"{",
"This",
":",
"m",
".",
"Reference",
"(",
")",
",",
"Name",
":",
"name",
",",
"Copy",
":",
"copy",
",",
"}",
"\n",
"if",
"dc",
"!=",
"nil",
"{",
"ref",
":=",
"dc",
".",
"Reference",
"(",
")",
"\n",
"req",
".",
"Datacenter",
"=",
"&",
"ref",
"\n",
"}",
"\n",
"res",
",",
"err",
":=",
"methods",
".",
"ShrinkVirtualDisk_Task",
"(",
"ctx",
",",
"m",
".",
"c",
",",
"&",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewTask",
"(",
"m",
".",
"c",
",",
"res",
".",
"Returnval",
")",
",",
"nil",
"\n",
"}"
] |
// ShrinkVirtualDisk shrinks a virtual disk.
|
[
"ShrinkVirtualDisk",
"shrinks",
"a",
"virtual",
"disk",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/object/virtual_disk_manager.go#L169-L187
|
train
|
vmware/govmomi
|
object/virtual_disk_manager.go
|
QueryVirtualDiskUuid
|
func (m VirtualDiskManager) QueryVirtualDiskUuid(ctx context.Context, name string, dc *Datacenter) (string, error) {
req := types.QueryVirtualDiskUuid{
This: m.Reference(),
Name: name,
}
if dc != nil {
ref := dc.Reference()
req.Datacenter = &ref
}
res, err := methods.QueryVirtualDiskUuid(ctx, m.c, &req)
if err != nil {
return "", err
}
if res == nil {
return "", nil
}
return res.Returnval, nil
}
|
go
|
func (m VirtualDiskManager) QueryVirtualDiskUuid(ctx context.Context, name string, dc *Datacenter) (string, error) {
req := types.QueryVirtualDiskUuid{
This: m.Reference(),
Name: name,
}
if dc != nil {
ref := dc.Reference()
req.Datacenter = &ref
}
res, err := methods.QueryVirtualDiskUuid(ctx, m.c, &req)
if err != nil {
return "", err
}
if res == nil {
return "", nil
}
return res.Returnval, nil
}
|
[
"func",
"(",
"m",
"VirtualDiskManager",
")",
"QueryVirtualDiskUuid",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
",",
"dc",
"*",
"Datacenter",
")",
"(",
"string",
",",
"error",
")",
"{",
"req",
":=",
"types",
".",
"QueryVirtualDiskUuid",
"{",
"This",
":",
"m",
".",
"Reference",
"(",
")",
",",
"Name",
":",
"name",
",",
"}",
"\n",
"if",
"dc",
"!=",
"nil",
"{",
"ref",
":=",
"dc",
".",
"Reference",
"(",
")",
"\n",
"req",
".",
"Datacenter",
"=",
"&",
"ref",
"\n",
"}",
"\n",
"res",
",",
"err",
":=",
"methods",
".",
"QueryVirtualDiskUuid",
"(",
"ctx",
",",
"m",
".",
"c",
",",
"&",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"res",
"==",
"nil",
"{",
"return",
"\"\"",
",",
"nil",
"\n",
"}",
"\n",
"return",
"res",
".",
"Returnval",
",",
"nil",
"\n",
"}"
] |
// Queries virtual disk uuid
|
[
"Queries",
"virtual",
"disk",
"uuid"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/object/virtual_disk_manager.go#L190-L211
|
train
|
vmware/govmomi
|
toolbox/service.go
|
NewService
|
func NewService(rpcIn Channel, rpcOut Channel) *Service {
s := &Service{
name: "toolbox", // Same name used by vmtoolsd
in: NewTraceChannel(rpcIn),
out: &ChannelOut{NewTraceChannel(rpcOut)},
handlers: make(map[string]Handler),
wg: new(sync.WaitGroup),
stop: make(chan struct{}),
PrimaryIP: DefaultIP,
}
s.RegisterHandler("reset", s.Reset)
s.RegisterHandler("ping", s.Ping)
s.RegisterHandler("Set_Option", s.SetOption)
s.RegisterHandler("Capabilities_Register", s.CapabilitiesRegister)
s.Command = registerCommandServer(s)
s.Command.FileServer = hgfs.NewServer()
s.Command.FileServer.RegisterFileHandler("proc", s.Command.ProcessManager)
s.Command.FileServer.RegisterFileHandler(hgfs.ArchiveScheme, hgfs.NewArchiveHandler())
s.Power = registerPowerCommandHandler(s)
return s
}
|
go
|
func NewService(rpcIn Channel, rpcOut Channel) *Service {
s := &Service{
name: "toolbox", // Same name used by vmtoolsd
in: NewTraceChannel(rpcIn),
out: &ChannelOut{NewTraceChannel(rpcOut)},
handlers: make(map[string]Handler),
wg: new(sync.WaitGroup),
stop: make(chan struct{}),
PrimaryIP: DefaultIP,
}
s.RegisterHandler("reset", s.Reset)
s.RegisterHandler("ping", s.Ping)
s.RegisterHandler("Set_Option", s.SetOption)
s.RegisterHandler("Capabilities_Register", s.CapabilitiesRegister)
s.Command = registerCommandServer(s)
s.Command.FileServer = hgfs.NewServer()
s.Command.FileServer.RegisterFileHandler("proc", s.Command.ProcessManager)
s.Command.FileServer.RegisterFileHandler(hgfs.ArchiveScheme, hgfs.NewArchiveHandler())
s.Power = registerPowerCommandHandler(s)
return s
}
|
[
"func",
"NewService",
"(",
"rpcIn",
"Channel",
",",
"rpcOut",
"Channel",
")",
"*",
"Service",
"{",
"s",
":=",
"&",
"Service",
"{",
"name",
":",
"\"toolbox\"",
",",
"in",
":",
"NewTraceChannel",
"(",
"rpcIn",
")",
",",
"out",
":",
"&",
"ChannelOut",
"{",
"NewTraceChannel",
"(",
"rpcOut",
")",
"}",
",",
"handlers",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"Handler",
")",
",",
"wg",
":",
"new",
"(",
"sync",
".",
"WaitGroup",
")",
",",
"stop",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"PrimaryIP",
":",
"DefaultIP",
",",
"}",
"\n",
"s",
".",
"RegisterHandler",
"(",
"\"reset\"",
",",
"s",
".",
"Reset",
")",
"\n",
"s",
".",
"RegisterHandler",
"(",
"\"ping\"",
",",
"s",
".",
"Ping",
")",
"\n",
"s",
".",
"RegisterHandler",
"(",
"\"Set_Option\"",
",",
"s",
".",
"SetOption",
")",
"\n",
"s",
".",
"RegisterHandler",
"(",
"\"Capabilities_Register\"",
",",
"s",
".",
"CapabilitiesRegister",
")",
"\n",
"s",
".",
"Command",
"=",
"registerCommandServer",
"(",
"s",
")",
"\n",
"s",
".",
"Command",
".",
"FileServer",
"=",
"hgfs",
".",
"NewServer",
"(",
")",
"\n",
"s",
".",
"Command",
".",
"FileServer",
".",
"RegisterFileHandler",
"(",
"\"proc\"",
",",
"s",
".",
"Command",
".",
"ProcessManager",
")",
"\n",
"s",
".",
"Command",
".",
"FileServer",
".",
"RegisterFileHandler",
"(",
"hgfs",
".",
"ArchiveScheme",
",",
"hgfs",
".",
"NewArchiveHandler",
"(",
")",
")",
"\n",
"s",
".",
"Power",
"=",
"registerPowerCommandHandler",
"(",
"s",
")",
"\n",
"return",
"s",
"\n",
"}"
] |
// NewService initializes a Service instance
|
[
"NewService",
"initializes",
"a",
"Service",
"instance"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/service.go#L75-L100
|
train
|
vmware/govmomi
|
toolbox/service.go
|
backoff
|
func (s *Service) backoff() {
if s.delay < maxDelay {
if s.delay > 0 {
d := s.delay * 2
if d > s.delay && d < maxDelay {
s.delay = d
} else {
s.delay = maxDelay
}
} else {
s.delay = 1
}
}
}
|
go
|
func (s *Service) backoff() {
if s.delay < maxDelay {
if s.delay > 0 {
d := s.delay * 2
if d > s.delay && d < maxDelay {
s.delay = d
} else {
s.delay = maxDelay
}
} else {
s.delay = 1
}
}
}
|
[
"func",
"(",
"s",
"*",
"Service",
")",
"backoff",
"(",
")",
"{",
"if",
"s",
".",
"delay",
"<",
"maxDelay",
"{",
"if",
"s",
".",
"delay",
">",
"0",
"{",
"d",
":=",
"s",
".",
"delay",
"*",
"2",
"\n",
"if",
"d",
">",
"s",
".",
"delay",
"&&",
"d",
"<",
"maxDelay",
"{",
"s",
".",
"delay",
"=",
"d",
"\n",
"}",
"else",
"{",
"s",
".",
"delay",
"=",
"maxDelay",
"\n",
"}",
"\n",
"}",
"else",
"{",
"s",
".",
"delay",
"=",
"1",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// backoff exponentially increases the RPC poll delay up to maxDelay
|
[
"backoff",
"exponentially",
"increases",
"the",
"RPC",
"poll",
"delay",
"up",
"to",
"maxDelay"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/service.go#L103-L116
|
train
|
vmware/govmomi
|
toolbox/service.go
|
Start
|
func (s *Service) Start() error {
err := s.startChannel()
if err != nil {
return err
}
s.wg.Add(1)
go func() {
defer s.wg.Done()
// Same polling interval and backoff logic as vmtoolsd.
// Required in our case at startup at least, otherwise it is possible
// we miss the 1 Capabilities_Register call for example.
// Note we Send(response) even when nil, to let the VMX know we are here
var response []byte
for {
select {
case <-s.stop:
s.stopChannel()
return
case <-time.After(time.Millisecond * 10 * s.delay):
if err = s.checkReset(); err != nil {
continue
}
err = s.in.Send(response)
response = nil
if err != nil {
s.delay = resetDelay
s.rpcError = true
continue
}
request, _ := s.in.Receive()
if len(request) > 0 {
response = s.Dispatch(request)
s.delay = 0
} else {
s.backoff()
}
}
}
}()
return nil
}
|
go
|
func (s *Service) Start() error {
err := s.startChannel()
if err != nil {
return err
}
s.wg.Add(1)
go func() {
defer s.wg.Done()
// Same polling interval and backoff logic as vmtoolsd.
// Required in our case at startup at least, otherwise it is possible
// we miss the 1 Capabilities_Register call for example.
// Note we Send(response) even when nil, to let the VMX know we are here
var response []byte
for {
select {
case <-s.stop:
s.stopChannel()
return
case <-time.After(time.Millisecond * 10 * s.delay):
if err = s.checkReset(); err != nil {
continue
}
err = s.in.Send(response)
response = nil
if err != nil {
s.delay = resetDelay
s.rpcError = true
continue
}
request, _ := s.in.Receive()
if len(request) > 0 {
response = s.Dispatch(request)
s.delay = 0
} else {
s.backoff()
}
}
}
}()
return nil
}
|
[
"func",
"(",
"s",
"*",
"Service",
")",
"Start",
"(",
")",
"error",
"{",
"err",
":=",
"s",
".",
"startChannel",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"s",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"s",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"var",
"response",
"[",
"]",
"byte",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"s",
".",
"stop",
":",
"s",
".",
"stopChannel",
"(",
")",
"\n",
"return",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"time",
".",
"Millisecond",
"*",
"10",
"*",
"s",
".",
"delay",
")",
":",
"if",
"err",
"=",
"s",
".",
"checkReset",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"in",
".",
"Send",
"(",
"response",
")",
"\n",
"response",
"=",
"nil",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"delay",
"=",
"resetDelay",
"\n",
"s",
".",
"rpcError",
"=",
"true",
"\n",
"continue",
"\n",
"}",
"\n",
"request",
",",
"_",
":=",
"s",
".",
"in",
".",
"Receive",
"(",
")",
"\n",
"if",
"len",
"(",
"request",
")",
">",
"0",
"{",
"response",
"=",
"s",
".",
"Dispatch",
"(",
"request",
")",
"\n",
"s",
".",
"delay",
"=",
"0",
"\n",
"}",
"else",
"{",
"s",
".",
"backoff",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Start initializes the RPC channels and starts a goroutine to listen for incoming RPC requests
|
[
"Start",
"initializes",
"the",
"RPC",
"channels",
"and",
"starts",
"a",
"goroutine",
"to",
"listen",
"for",
"incoming",
"RPC",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/service.go#L147-L196
|
train
|
vmware/govmomi
|
toolbox/service.go
|
RegisterHandler
|
func (s *Service) RegisterHandler(name string, handler Handler) {
s.handlers[name] = handler
}
|
go
|
func (s *Service) RegisterHandler(name string, handler Handler) {
s.handlers[name] = handler
}
|
[
"func",
"(",
"s",
"*",
"Service",
")",
"RegisterHandler",
"(",
"name",
"string",
",",
"handler",
"Handler",
")",
"{",
"s",
".",
"handlers",
"[",
"name",
"]",
"=",
"handler",
"\n",
"}"
] |
// RegisterHandler for the given RPC name
|
[
"RegisterHandler",
"for",
"the",
"given",
"RPC",
"name"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/service.go#L212-L214
|
train
|
vmware/govmomi
|
toolbox/service.go
|
Dispatch
|
func (s *Service) Dispatch(request []byte) []byte {
msg := bytes.SplitN(request, []byte{' '}, 2)
name := msg[0]
// Trim NULL byte terminator
name = bytes.TrimRight(name, "\x00")
handler, ok := s.handlers[string(name)]
if !ok {
log.Printf("unknown command: %q\n", name)
return []byte("Unknown Command")
}
var args []byte
if len(msg) == 2 {
args = msg[1]
}
response, err := handler(args)
if err == nil {
response = append([]byte("OK "), response...)
} else {
log.Printf("error calling %s: %s\n", name, err)
response = append([]byte("ERR "), response...)
}
return response
}
|
go
|
func (s *Service) Dispatch(request []byte) []byte {
msg := bytes.SplitN(request, []byte{' '}, 2)
name := msg[0]
// Trim NULL byte terminator
name = bytes.TrimRight(name, "\x00")
handler, ok := s.handlers[string(name)]
if !ok {
log.Printf("unknown command: %q\n", name)
return []byte("Unknown Command")
}
var args []byte
if len(msg) == 2 {
args = msg[1]
}
response, err := handler(args)
if err == nil {
response = append([]byte("OK "), response...)
} else {
log.Printf("error calling %s: %s\n", name, err)
response = append([]byte("ERR "), response...)
}
return response
}
|
[
"func",
"(",
"s",
"*",
"Service",
")",
"Dispatch",
"(",
"request",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"msg",
":=",
"bytes",
".",
"SplitN",
"(",
"request",
",",
"[",
"]",
"byte",
"{",
"' '",
"}",
",",
"2",
")",
"\n",
"name",
":=",
"msg",
"[",
"0",
"]",
"\n",
"name",
"=",
"bytes",
".",
"TrimRight",
"(",
"name",
",",
"\"\\x00\"",
")",
"\n",
"\\x00",
"\n",
"handler",
",",
"ok",
":=",
"s",
".",
"handlers",
"[",
"string",
"(",
"name",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"log",
".",
"Printf",
"(",
"\"unknown command: %q\\n\"",
",",
"\\n",
")",
"\n",
"name",
"\n",
"}",
"\n",
"return",
"[",
"]",
"byte",
"(",
"\"Unknown Command\"",
")",
"\n",
"var",
"args",
"[",
"]",
"byte",
"\n",
"if",
"len",
"(",
"msg",
")",
"==",
"2",
"{",
"args",
"=",
"msg",
"[",
"1",
"]",
"\n",
"}",
"\n",
"response",
",",
"err",
":=",
"handler",
"(",
"args",
")",
"\n",
"}"
] |
// Dispatch an incoming RPC request to a Handler
|
[
"Dispatch",
"an",
"incoming",
"RPC",
"request",
"to",
"a",
"Handler"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/service.go#L217-L245
|
train
|
vmware/govmomi
|
toolbox/service.go
|
Reset
|
func (s *Service) Reset([]byte) ([]byte, error) {
s.SendGuestInfo() // Send the IP info ASAP
return []byte("ATR " + s.name), nil
}
|
go
|
func (s *Service) Reset([]byte) ([]byte, error) {
s.SendGuestInfo() // Send the IP info ASAP
return []byte("ATR " + s.name), nil
}
|
[
"func",
"(",
"s",
"*",
"Service",
")",
"Reset",
"(",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"s",
".",
"SendGuestInfo",
"(",
")",
"\n",
"return",
"[",
"]",
"byte",
"(",
"\"ATR \"",
"+",
"s",
".",
"name",
")",
",",
"nil",
"\n",
"}"
] |
// Reset is the default Handler for reset requests
|
[
"Reset",
"is",
"the",
"default",
"Handler",
"for",
"reset",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/service.go#L248-L252
|
train
|
vmware/govmomi
|
toolbox/service.go
|
SetOption
|
func (s *Service) SetOption(args []byte) ([]byte, error) {
opts := bytes.SplitN(args, []byte{' '}, 2)
key := string(opts[0])
val := string(opts[1])
if Trace {
fmt.Fprintf(os.Stderr, "set option %q=%q\n", key, val)
}
switch key {
case "broadcastIP": // TODO: const-ify
if val == "1" {
ip := s.PrimaryIP()
if ip == "" {
log.Printf("failed to find primary IP")
return nil, nil
}
msg := fmt.Sprintf("info-set guestinfo.ip %s", ip)
_, err := s.out.Request([]byte(msg))
if err != nil {
return nil, err
}
s.SendGuestInfo()
}
default:
// TODO: handle other options...
}
return nil, nil
}
|
go
|
func (s *Service) SetOption(args []byte) ([]byte, error) {
opts := bytes.SplitN(args, []byte{' '}, 2)
key := string(opts[0])
val := string(opts[1])
if Trace {
fmt.Fprintf(os.Stderr, "set option %q=%q\n", key, val)
}
switch key {
case "broadcastIP": // TODO: const-ify
if val == "1" {
ip := s.PrimaryIP()
if ip == "" {
log.Printf("failed to find primary IP")
return nil, nil
}
msg := fmt.Sprintf("info-set guestinfo.ip %s", ip)
_, err := s.out.Request([]byte(msg))
if err != nil {
return nil, err
}
s.SendGuestInfo()
}
default:
// TODO: handle other options...
}
return nil, nil
}
|
[
"func",
"(",
"s",
"*",
"Service",
")",
"SetOption",
"(",
"args",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"opts",
":=",
"bytes",
".",
"SplitN",
"(",
"args",
",",
"[",
"]",
"byte",
"{",
"' '",
"}",
",",
"2",
")",
"\n",
"key",
":=",
"string",
"(",
"opts",
"[",
"0",
"]",
")",
"\n",
"val",
":=",
"string",
"(",
"opts",
"[",
"1",
"]",
")",
"\n",
"if",
"Trace",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"set option %q=%q\\n\"",
",",
"\\n",
",",
"key",
")",
"\n",
"}",
"\n",
"val",
"\n",
"switch",
"key",
"{",
"case",
"\"broadcastIP\"",
":",
"if",
"val",
"==",
"\"1\"",
"{",
"ip",
":=",
"s",
".",
"PrimaryIP",
"(",
")",
"\n",
"if",
"ip",
"==",
"\"\"",
"{",
"log",
".",
"Printf",
"(",
"\"failed to find primary IP\"",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"info-set guestinfo.ip %s\"",
",",
"ip",
")",
"\n",
"_",
",",
"err",
":=",
"s",
".",
"out",
".",
"Request",
"(",
"[",
"]",
"byte",
"(",
"msg",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"s",
".",
"SendGuestInfo",
"(",
")",
"\n",
"}",
"\n",
"default",
":",
"}",
"\n",
"}"
] |
// SetOption is the default Handler for Set_Option requests
|
[
"SetOption",
"is",
"the",
"default",
"Handler",
"for",
"Set_Option",
"requests"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/service.go#L260-L290
|
train
|
vmware/govmomi
|
toolbox/service.go
|
DefaultIP
|
func DefaultIP() string {
addrs, err := netInterfaceAddrs()
if err == nil {
for _, addr := range addrs {
if ip, ok := addr.(*net.IPNet); ok && !ip.IP.IsLoopback() {
if ip.IP.To4() != nil {
return ip.IP.String()
}
}
}
}
return ""
}
|
go
|
func DefaultIP() string {
addrs, err := netInterfaceAddrs()
if err == nil {
for _, addr := range addrs {
if ip, ok := addr.(*net.IPNet); ok && !ip.IP.IsLoopback() {
if ip.IP.To4() != nil {
return ip.IP.String()
}
}
}
}
return ""
}
|
[
"func",
"DefaultIP",
"(",
")",
"string",
"{",
"addrs",
",",
"err",
":=",
"netInterfaceAddrs",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"for",
"_",
",",
"addr",
":=",
"range",
"addrs",
"{",
"if",
"ip",
",",
"ok",
":=",
"addr",
".",
"(",
"*",
"net",
".",
"IPNet",
")",
";",
"ok",
"&&",
"!",
"ip",
".",
"IP",
".",
"IsLoopback",
"(",
")",
"{",
"if",
"ip",
".",
"IP",
".",
"To4",
"(",
")",
"!=",
"nil",
"{",
"return",
"ip",
".",
"IP",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"\"",
"\n",
"}"
] |
// DefaultIP is used by default when responding to a Set_Option broadcastIP request
// It can be overridden with the Service.PrimaryIP field
|
[
"DefaultIP",
"is",
"used",
"by",
"default",
"when",
"responding",
"to",
"a",
"Set_Option",
"broadcastIP",
"request",
"It",
"can",
"be",
"overridden",
"with",
"the",
"Service",
".",
"PrimaryIP",
"field"
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/toolbox/service.go#L294-L307
|
train
|
vmware/govmomi
|
object/namespace_manager.go
|
CreateDirectory
|
func (nm DatastoreNamespaceManager) CreateDirectory(ctx context.Context, ds *Datastore, displayName string, policy string) (string, error) {
req := &types.CreateDirectory{
This: nm.Reference(),
Datastore: ds.Reference(),
DisplayName: displayName,
Policy: policy,
}
resp, err := methods.CreateDirectory(ctx, nm.c, req)
if err != nil {
return "", err
}
return resp.Returnval, nil
}
|
go
|
func (nm DatastoreNamespaceManager) CreateDirectory(ctx context.Context, ds *Datastore, displayName string, policy string) (string, error) {
req := &types.CreateDirectory{
This: nm.Reference(),
Datastore: ds.Reference(),
DisplayName: displayName,
Policy: policy,
}
resp, err := methods.CreateDirectory(ctx, nm.c, req)
if err != nil {
return "", err
}
return resp.Returnval, nil
}
|
[
"func",
"(",
"nm",
"DatastoreNamespaceManager",
")",
"CreateDirectory",
"(",
"ctx",
"context",
".",
"Context",
",",
"ds",
"*",
"Datastore",
",",
"displayName",
"string",
",",
"policy",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"req",
":=",
"&",
"types",
".",
"CreateDirectory",
"{",
"This",
":",
"nm",
".",
"Reference",
"(",
")",
",",
"Datastore",
":",
"ds",
".",
"Reference",
"(",
")",
",",
"DisplayName",
":",
"displayName",
",",
"Policy",
":",
"policy",
",",
"}",
"\n",
"resp",
",",
"err",
":=",
"methods",
".",
"CreateDirectory",
"(",
"ctx",
",",
"nm",
".",
"c",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Returnval",
",",
"nil",
"\n",
"}"
] |
// CreateDirectory creates a top-level directory on the given vsan datastore, using
// the given user display name hint and opaque storage policy.
|
[
"CreateDirectory",
"creates",
"a",
"top",
"-",
"level",
"directory",
"on",
"the",
"given",
"vsan",
"datastore",
"using",
"the",
"given",
"user",
"display",
"name",
"hint",
"and",
"opaque",
"storage",
"policy",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/object/namespace_manager.go#L41-L56
|
train
|
vmware/govmomi
|
object/namespace_manager.go
|
DeleteDirectory
|
func (nm DatastoreNamespaceManager) DeleteDirectory(ctx context.Context, dc *Datacenter, datastorePath string) error {
req := &types.DeleteDirectory{
This: nm.Reference(),
DatastorePath: datastorePath,
}
if dc != nil {
ref := dc.Reference()
req.Datacenter = &ref
}
if _, err := methods.DeleteDirectory(ctx, nm.c, req); err != nil {
return err
}
return nil
}
|
go
|
func (nm DatastoreNamespaceManager) DeleteDirectory(ctx context.Context, dc *Datacenter, datastorePath string) error {
req := &types.DeleteDirectory{
This: nm.Reference(),
DatastorePath: datastorePath,
}
if dc != nil {
ref := dc.Reference()
req.Datacenter = &ref
}
if _, err := methods.DeleteDirectory(ctx, nm.c, req); err != nil {
return err
}
return nil
}
|
[
"func",
"(",
"nm",
"DatastoreNamespaceManager",
")",
"DeleteDirectory",
"(",
"ctx",
"context",
".",
"Context",
",",
"dc",
"*",
"Datacenter",
",",
"datastorePath",
"string",
")",
"error",
"{",
"req",
":=",
"&",
"types",
".",
"DeleteDirectory",
"{",
"This",
":",
"nm",
".",
"Reference",
"(",
")",
",",
"DatastorePath",
":",
"datastorePath",
",",
"}",
"\n",
"if",
"dc",
"!=",
"nil",
"{",
"ref",
":=",
"dc",
".",
"Reference",
"(",
")",
"\n",
"req",
".",
"Datacenter",
"=",
"&",
"ref",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"methods",
".",
"DeleteDirectory",
"(",
"ctx",
",",
"nm",
".",
"c",
",",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// DeleteDirectory deletes the given top-level directory from a vsan datastore.
|
[
"DeleteDirectory",
"deletes",
"the",
"given",
"top",
"-",
"level",
"directory",
"from",
"a",
"vsan",
"datastore",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/object/namespace_manager.go#L59-L76
|
train
|
vmware/govmomi
|
performance/manager.go
|
NewManager
|
func NewManager(client *vim25.Client) *Manager {
m := Manager{
Common: object.NewCommon(client, *client.ServiceContent.PerfManager),
}
m.pm.PerformanceManager = new(mo.PerformanceManager)
return &m
}
|
go
|
func NewManager(client *vim25.Client) *Manager {
m := Manager{
Common: object.NewCommon(client, *client.ServiceContent.PerfManager),
}
m.pm.PerformanceManager = new(mo.PerformanceManager)
return &m
}
|
[
"func",
"NewManager",
"(",
"client",
"*",
"vim25",
".",
"Client",
")",
"*",
"Manager",
"{",
"m",
":=",
"Manager",
"{",
"Common",
":",
"object",
".",
"NewCommon",
"(",
"client",
",",
"*",
"client",
".",
"ServiceContent",
".",
"PerfManager",
")",
",",
"}",
"\n",
"m",
".",
"pm",
".",
"PerformanceManager",
"=",
"new",
"(",
"mo",
".",
"PerformanceManager",
")",
"\n",
"return",
"&",
"m",
"\n",
"}"
] |
// NewManager creates a new Manager instance.
|
[
"NewManager",
"creates",
"a",
"new",
"Manager",
"instance",
"."
] |
fc3f0e9d2275df0e497a80917807a7c72d3c35bc
|
https://github.com/vmware/govmomi/blob/fc3f0e9d2275df0e497a80917807a7c72d3c35bc/performance/manager.go#L58-L66
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.