id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c21500 | 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,... | |
c21501 | 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)
} | |
c21502 | url := internal.URL(c, internal.CategoryPath).WithID(category.ID)
return c.Do(ctx, url.Request(http.MethodDelete), nil)
} | |
c21503 |
}
url := internal.URL(c, internal.CategoryPath).WithID(id)
var res Category
return &res, c.Do(ctx, url.Request(http.MethodGet), &res)
} | |
c21504 | res []string
return res, c.Do(ctx, url.Request(http.MethodGet), &res)
} | |
c21505 | }
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
} | |
c21506 |
{internal.LibraryItemUpdateSession + "/", s.libraryItemUpdateSessionID},
{internal.LibraryItemUpdateSessionFile, s.libraryItemUpdateSessionFile},
{internal.LibraryItemUpdateSessionFile + "/", s.libraryItemUpdateSessionFileID},
{internal.LibraryItemAdd + "/", s.libraryItemAdd},
{internal.LibraryItemFilePath, ... | |
c21507 | := range s.Association[t.ID] {
ids = append(ids, vim.ManagedObjectReference(id))
}
return ids, nil
} | |
c21508 | s.Tag[id]
cat := s.Category[tag.CategoryID]
tags = append(tags, vim.VslmTagEntry{
TagName: tag.Name,
ParentCategoryName: cat.Name,
})
}
}
return tags, nil
} | |
c21509 | s.Association[t.ID][internal.AssociatedObject(ref)] = true
return nil
} | |
c21510 | delete(s.Association[t.ID], internal.AssociatedObject(id))
return nil
} | |
c21511 | {
return
}
err := json.NewEncoder(w).Encode(struct {
Value interface{} `json:"value,omitempty"`
}{
val[0],
})
if err != nil {
log.Panic(err)
}
} | |
c21512 | http.MethodGet, http.MethodPatch, http.MethodPut:
default:
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
h, _ := s.Handler(r)
h.ServeHTTP(w, r)
} | |
c21513 | := strings.SplitN(l.Storage[0].DatastoreID, "@", 2)[0]
return path.Join(append([]string{ds, "contentlib-" + l.ID}, id)...)
} | |
c21514 | nil {
return nil, err
}
tarFile := tar.NewReader(f)
return &OVAFile{filename: filename, file: f, tarFile: tarFile}, nil
} | |
c21515 | of.tarFile.Next()
if err == io.EOF {
return nil, err
}
if header.Name == filename {
return header, nil
}
}
} | |
c21516 | io.EOF
}
return of.tarFile.Read(b)
} | |
c21517 | 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
} | |
c21518 |
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.Se... | |
c21519 | if Map.FindByName(p.Datastore, h.Datastore) != nil {
attached = append(attached, host)
}
}
return attached
} | |
c21520 | if err != nil {
return "", err
}
return fmt.Sprintf("%s%s", xml.Header, x), nil
} | |
c21521 | 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()
} | |
c21522 | errors.New("non-pointer passed to Unmarshal")
}
return d.unmarshal(val.Elem(), start)
} | |
c21523 | t.String()
}
return "(" + t.String() + ")"
} | |
c21524 |
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 {
... | |
c21525 | 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.
f... | |
c21526 | err != nil {
return err
}
case EndElement:
return nil
}
}
} | |
c21527 | `json:"file_spec"`
}{updateFile}
var res UpdateFileInfo
return &res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
} | |
c21528 | URI: uri,
SSLCertificateThumbprint: fingerprint,
},
})
if err != nil {
return nil, err
}
return info, c.CompleteLibraryItemUpdateSession(ctx, sessionID)
} | |
c21529 | string `json:"file_name"`
}{fileName}
var res UpdateFileInfo
return &res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
} | |
c21530 | 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
} | |
c21531 | 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)
}
} | |
c21532 |
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) {
retu... | |
c21533 | types.ManagedObjectReference, _ *types.EntityEventArgument) bool {
return self == ref
})
} | |
c21534 | func(child types.ManagedObjectReference) {
if child == self {
seen = true
return
}
walk(child, match)
}
walk(ref, match)
return seen
})
} | |
c21535 | 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.Enti... | |
c21536 | matches(kind.Name()) {
return true // concrete type
}
field, ok := kind.FieldByNameFunc(matches)
if ok {
return field.Anonymous // base type (embedded field)
}
return false
} | |
c21537 |
if !c.typeMatches(event, &spec) {
return false
}
// TODO: spec.Time, spec.UserName, etc
return c.entityMatches(event, &spec)
} | |
c21538 | 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
}
}
}
} | |
c21539 |
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
} | |
c21540 | 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
} | |
c21541 | 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
} | |
c21542 |
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
} | |
c21543 | = 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
} | |
c21544 | s.delay = d
} else {
s.delay = maxDelay
}
} else {
s.delay = 1
}
}
} | |
c21545 | 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
} | |
c21546 |
s.handlers[name] = handler
} | |
c21547 | err == nil {
response = append([]byte("OK "), response...)
} else {
log.Printf("error calling %s: %s\n", name, err)
response = append([]byte("ERR "), response...)
}
return response
} | |
c21548 | info ASAP
return []byte("ATR " + s.name), nil
} | |
c21549 | 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
} | |
c21550 | ip.IP.To4() != nil {
return ip.IP.String()
}
}
}
}
return ""
} | |
c21551 | 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
} | |
c21552 | if dc != nil {
ref := dc.Reference()
req.Datacenter = &ref
}
if _, err := methods.DeleteDirectory(ctx, nm.c, req); err != nil {
return err
}
return nil
} | |
c21553 |
m.pm.PerformanceManager = new(mo.PerformanceManager)
return &m
} | |
c21554 | err != nil {
return nil, err
}
return IntervalList(pm.HistoricalInterval), nil
} | |
c21555 | []string{"perfCounter"}, m.pm.PerformanceManager)
if err != nil {
return nil, err
}
}
return m.pm.PerfCounter, nil
} | |
c21556 | {
return nil, err
}
m.infoByKey.m = make(map[int32]*types.PerfCounterInfo)
for i := range info {
c := &info[i]
m.infoByKey.m[c.Key] = c
}
return m.infoByKey.m, nil
} | |
c21557 | This: m.Reference(),
Entity: entity,
}
res, err := methods.QueryPerfProviderSummary(ctx, m.Client(), &req)
if err != nil {
return nil, err
}
return &res.Returnval, nil
} | |
c21558 | := m.CounterInfoByKey(ctx)
if err != nil {
return nil, err
}
sort.Sort(groupPerfCounterInfo{info, res.Returnval})
}
return MetricList(res.Returnval), nil
} | |
c21559 | err := methods.QueryPerf(ctx, m.Client(), &req)
if err != nil {
return nil, err
}
return res.Returnval, nil
} | |
c21560 | vals[i] = s.Format(s.Value[i])
}
return strings.Join(vals, ",")
} | |
c21561 | := range m.SampleInfo {
vals[i] = s.Timestamp.Format(time.RFC3339)
i++
vals[i] = strconv.Itoa(int(s.Interval))
i++
}
return strings.Join(vals, ",")
} | |
c21562 | t := c.Transport.(*http.Transport)
_ = info.FromURL(&url.URL{Host: spec.HostName}, t.TLSClientConfig)
spec.SslThumbprint = info.ThumbprintSHA1
}
}
return spec
} | |
c21563 | {
switch fault := f.Fault().(type) {
case *types.SSLVerifyFault:
return fmt.Errorf("%s thumbprint=%s", err, fault.Thumbprint)
}
}
return err
} | |
c21564 | return err
}
u, err := c.FileManager.TransferURL(ctx, url)
if err != nil {
return err
}
p := soap.DefaultUpload
p.ContentLength = size
err = vc.Client.Upload(ctx, &buf, u, &p)
if err != nil {
return err
}
}
names := []string{"out", "err"}
for i, w := range []io.Writer{cmd.Stdout, cmd.... | |
c21565 | vc.Download(ctx, u, &p)
if err != nil {
return nil, n, err
}
if strings.HasPrefix(src, "/archive:/") || isDir(src) {
f = &archiveReader{ReadCloser: f} // look for the gzip trailer
}
return f, n, nil
} | |
c21566 |
if err != nil {
return err
}
src = buf
}
}
url, err := c.FileManager.InitiateFileTransferToGuest(ctx, c.Authentication, dst, attr, p.ContentLength, force)
if err != nil {
return err
}
u, err := c.FileManager.TransferURL(ctx, url)
if err != nil {
return err
}
return vc.Client.Upload(ctx, ... | |
c21567 | && rule.Port == r.Port ||
rule.Port >= r.Port && rule.Port <= r.EndPort {
matches = append(matches, rs)
break
}
}
}
return matches
} | |
c21568 |
if rs.Enabled {
matches = append(matches, rs)
}
}
return matches
} | |
c21569 | {
keys = append(keys, rs.Key)
}
return keys
} | |
c21570 | return v.Copy()
case ProcInst:
return v.Copy()
case StartElement:
return v.Copy()
}
return t
} | |
c21571 | 1,
Strict: true,
}
d.switchToReader(r)
return d
} | |
c21572 | || d.stk.kind != stkEOF {
return false
}
d.pop()
return true
} | |
c21573 | := d.push(stkStart)
s.name = name
} | |
c21574 | &SyntaxError{Msg: msg, Line: d.line}
} | |
c21575 | </" + name.Local + ">")
return false
case s.name.Space != name.Space:
d.err = d.syntaxError("element <" + s.name.Local + "> in space " + s.name.Space +
"closed by </" + name.Local + "> in space " + name.Space)
return false
}
// Pop stack until a Start or EOF is on the top, undoing the
// translations tha... | |
c21576 | {
if strings.ToLower(s) == name {
// This one should be auto closed if t doesn't close it.
et, ok := t.(EndElement)
if !ok || et.Name.Local != name {
return EndElement{d.stk.name}, true
}
break
}
}
return nil, false
} | |
c21577 | d.unmarshalDepth > 0 {
return nil, errRawToken
}
return d.rawToken()
} | |
c21578 | '\t':
default:
d.ungetc(b)
return
}
}
} | |
c21579 | -1
} else {
b, d.err = d.r.ReadByte()
if d.err != nil {
return 0, false
}
if d.saved != nil {
d.saved.WriteByte(b)
}
}
if b == '\n' {
d.line++
}
return b, true
} | |
c21580 | d.mustgetc(); !ok {
return
}
if b < utf8.RuneSelf && !isNameByte(b) {
d.ungetc(b)
break
}
d.buf.WriteByte(b)
}
return true
} | |
c21581 | idx == -1 {
return ""
}
v := s[idx+len("encoding="):]
if v == "" {
return ""
}
if v[0] != '\'' && v[0] != '"' {
return ""
}
idx = strings.IndexRune(v[1:], rune(v[0]))
if idx == -1 {
return ""
}
return v[1 : idx+1]
} | |
c21582 | }
if err := p.Properties(ctx, *dvp.Config.DistributedVirtualSwitch, []string{"uuid"}, &dvs); err != nil {
return nil, err
}
backing := &types.VirtualEthernetCardDistributedVirtualPortBackingInfo{
Port: types.DistributedVirtualSwitchPortConnection{
PortgroupKey: dvp.Key,
SwitchUuid: dvs.Uuid,
},
}
... | |
c21583 | methods.AddPortGroup(ctx, o.c, &req)
if err != nil {
return err
}
return nil
} | |
c21584 | nic,
}
res, err := methods.AddServiceConsoleVirtualNic(ctx, o.c, &req)
if err != nil {
return "", err
}
return res.Returnval, nil
} | |
c21585 | spec,
}
_, err := methods.AddVirtualSwitch(ctx, o.c, &req)
if err != nil {
return err
}
return nil
} | |
c21586 | This: o.Reference(),
Device: device,
}
_, err := methods.QueryNetworkHint(ctx, o.c, &req)
if err != nil {
return err
}
return nil
} | |
c21587 | err := methods.RefreshNetworkSystem(ctx, o.c, &req)
if err != nil {
return err
}
return nil
} | |
c21588 | This: o.Reference(),
PgName: pgName,
}
_, err := methods.RemovePortGroup(ctx, o.c, &req)
if err != nil {
return err
}
return nil
} | |
c21589 |
_, err := methods.RemoveVirtualSwitch(ctx, o.c, &req)
if err != nil {
return err
}
return nil
} | |
c21590 | methods.UpdateConsoleIpRouteConfig(ctx, o.c, &req)
if err != nil {
return err
}
return nil
} | |
c21591 | config,
ChangeMode: changeMode,
}
res, err := methods.UpdateNetworkConfig(ctx, o.c, &req)
if err != nil {
return nil, err
}
return &res.Returnval, nil
} | |
c21592 | LinkSpeed: linkSpeed,
}
_, err := methods.UpdatePhysicalNicLinkSpeed(ctx, o.c, &req)
if err != nil {
return err
}
return nil
} | |
c21593 | }
_, err := methods.UpdatePortGroup(ctx, o.c, &req)
if err != nil {
return err
}
return nil
} | |
c21594 |
}
_, err := methods.UpdateVirtualNic(ctx, o.c, &req)
if err != nil {
return err
}
return nil
} | |
c21595 |
l, err := m.CreateListView(ctx, nil)
if err != nil {
return nil, err
}
tv := &TaskView{
ListView: l,
Watch: watch,
}
return tv, nil
} | |
c21596 | }
completed = rtasks
}
}
continue
}
info, ok := change.Val.(types.TaskInfo)
if !ok {
continue
}
if !completed[info.Task.Value] {
infos = append(infos, info)
}
if v.Follow && info.CompleteTime != nil {
prune = append(prune, info.Task)
complet... | |
c21597 | internal.URL(c, internal.VCenterOVFLibraryItem).WithID(libraryItemID).WithAction("deploy")
var res Deployment
return res, c.Do(ctx, url.Request(http.MethodPost, deploy), &res)
} | |
c21598 | url := internal.URL(c, internal.VCenterOVFLibraryItem).WithID(libraryItemID).WithAction("filter")
var res FilterResponse
return res, c.Do(ctx, url.Request(http.MethodPost, filter), &res)
} | |
c21599 | c.Client.NewServiceClient(internal.Path, "")
return &Client{sc}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.