id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c21600 | res.StatusCode {
case http.StatusOK:
case http.StatusBadRequest:
// TODO: structured error types
detail, err := ioutil.ReadAll(res.Body)
if err != nil {
return err
}
return fmt.Errorf("%s: %s", res.Status, bytes.TrimSpace(detail))
default:
return fmt.Errorf("%s %s: %s", req.Method, req.URL,... | |
c21601 |
if user != nil {
if password, ok := user.Password(); ok {
req.SetBasicAuth(user.Username(), password)
}
}
return c.Do(ctx, req, nil)
} | |
c21602 | internal.SessionPath).Request(http.MethodDelete)
return c.Do(ctx, req, nil)
} | |
c21603 |
req := types.RetrieveServiceContent{
This: ServiceInstance,
}
res, err := methods.RetrieveServiceContent(ctx, sc, &req)
if err != nil {
return nil, err
}
return &Client{sc, res.Returnval}, nil
} | |
c21604 | if len(info) != 0 && len(info[0].ServiceEndpoints) != 0 {
endpoint := &info[0].ServiceEndpoints[0]
path = endpoint.Url
if u, err := url.Parse(path); err == nil {
if c.Thumbprint(u.Host) == "" {
c.SetThumbprint(u.Host, endpointThumbprint(endpoint))
}
}
}
}
return path
} | |
c21605 |
cert, err := x509.ParseCertificate(b)
if err != nil {
log.Printf("x509.ParseCertificate(%q): %s", enc, err)
return ""
}
return soap.ThumbprintSHA1(cert)
} | |
c21606 | cdp,
}
res, err := methods.CreateDescriptor(ctx, m.c, &req)
if err != nil {
return nil, err
}
return &res.Returnval, nil
} | |
c21607 |
This: m.Reference(),
OvfDescriptor: ovfDescriptor,
ResourcePool: resourcePool.Reference(),
Datastore: datastore.Reference(),
Cisp: cisp,
}
res, err := methods.CreateImportSpec(ctx, m.c, &req)
if err != nil {
return nil, err
}
return &res.Returnval, nil
} | |
c21608 |
res, err := methods.ParseDescriptor(ctx, m.c, &req)
if err != nil {
return nil, err
}
return &res.Returnval, nil
} | |
c21609 | vhp,
}
res, err := methods.ValidateHost(ctx, m.c, &req)
if err != nil {
return nil, err
}
return &res.Returnval, nil
} | |
c21610 | item.Name,
Description: item.Description,
LibraryID: item.LibraryID,
Type: item.Type,
},
}
url := internal.URL(c, internal.LibraryItemPath)
var res string
return res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
} | |
c21611 | internal.LibraryItemPath).WithID(item.ID)
return c.Do(ctx, url.Request(http.MethodDelete), nil)
} | |
c21612 | internal.LibraryItemPath).WithParameter("library_id", id)
var res []string
return res, c.Do(ctx, url.Request(http.MethodGet), &res)
} | |
c21613 | var res Item
return &res, c.Do(ctx, url.Request(http.MethodGet), &res)
} | |
c21614 | failed for: %s", err)
}
var items []Item
for _, id := range ids {
item, err := c.GetLibraryItem(ctx, id)
if err != nil {
return nil, fmt.Errorf("get library item for %s failed for %s", id, err)
}
items = append(items, *item)
}
return items, nil
} | |
c21615 | `json:"spec"`
}{search}
var res []string
return res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
} | |
c21616 |
if err != nil {
return nil, err
}
info := &FirewallInfo{
Loaded: res.Values[0]["Loaded"][0] == "true",
Enabled: res.Values[0]["Enabled"][0] == "true",
DefaultAction: res.Values[0]["DefaultAction"][0],
}
return info, nil
} | |
c21617 | KeepAliveHandler(roundTripper, idleTime, defaultKeepAlive)
} | |
c21618 |
return err
}
spec := internal.NewAssociation(ref)
url := internal.URL(c, internal.AssociationPath).WithID(id).WithAction("attach")
return c.Do(ctx, url.Request(http.MethodPost, spec), nil)
} | |
c21619 | internal.AssociationPath).WithAction("list-attached-tags")
var res []string
return res, c.Do(ctx, url.Request(http.MethodPost, spec), &res)
} | |
c21620 | range ids {
tag, err := c.GetTag(ctx, id)
if err != nil {
return nil, fmt.Errorf("get tag %s: %s", id, err)
}
info = append(info, *tag)
}
return info, nil
} | |
c21621 | url.Request(http.MethodPost, nil), &res); err != nil {
return nil, err
}
refs := make([]mo.Reference, len(res))
for i := range res {
refs[i] = res[i]
}
return refs, nil
} | |
c21622 |
if bytes.HasPrefix(reply, rpciOK) {
return reply[2:], nil
}
return nil, fmt.Errorf("request %q: %q", request, reply)
} | |
c21623 | }
mes = mes[:i]
}
var p string
for _, me := range mes {
// Skip root entity in building inventory path.
if me.Parent == nil {
continue
}
p = p + "/" + me.Name
}
return p, nil
} | |
c21624 | if len(e) == 0 {
return nil, &NotFoundError{ref.Type, ref.Value}
}
if len(e) > 1 {
panic("ManagedObjectReference must be unique")
}
return &e[0], nil
} | |
c21625 | }
r.(common).SetInventoryPath(e.Path)
if f.dc != nil {
if ds, ok := r.(*object.Datastore); ok {
ds.DatacenterPath = f.dc.InventoryPath
}
}
return r, nil
} | |
c21626 | := err.(*NotFoundError); !ok {
return nil, err
}
vapps, _ := f.VirtualAppList(ctx, path)
if len(vapps) == 0 {
return nil, err
}
for _, vapp := range vapps {
pools = append(pools, vapp.ResourcePool)
}
}
return pools, nil
} | |
c21627 | err := enc.Encode(v); err != nil {
return nil, err
}
return b.Bytes(), nil
} | |
c21628 | = prefix
enc.p.indent = indent
} | |
c21629 | err != nil {
return err
}
return enc.p.Flush()
} | |
c21630 | &start)
if err != nil {
return err
}
return enc.p.Flush()
} | |
c21631 | {
delete(p.attrPrefix, p.attrNS[prefix])
delete(p.attrNS, prefix)
} | |
c21632 | } else {
// Must be a pointer to a named type,
// since it has the Marshaler methods.
start.Name.Local = typ.Elem().Name()
}
// Add type attribute if necessary
if finfo != nil && finfo.flags&fTypeAttr != 0 {
start.Attr = append(start.Attr, Attr{xmlSchemaInstance, typeToString(typ)})
}
return start
} | |
c21633 | err := val.MarshalXML(p.encoder, start)
if err != nil {
return err
}
// Make sure MarshalXML closed all its tags. p.tags[n-1] is the mark.
if len(p.tags) > n {
return fmt.Errorf("xml: %s.MarshalXML wrote invalid XML: <%s> not closed", receiverType(val), p.tags[len(p.tags)-1].Local)
}
p.tags = p.tags[:n-1]
... | |
c21634 | != nil {
return err
}
text, err := val.MarshalText()
if err != nil {
return err
}
EscapeText(p, text)
return p.writeEnd(start.Name)
} | |
c21635 | continue
}
p.WriteByte(' ')
if name.Space != "" {
p.WriteString(p.createAttrPrefix(name.Space))
p.WriteByte(':')
}
p.WriteString(name.Local)
p.WriteString(`="`)
p.EscapeString(attr.Value)
p.WriteByte('"')
}
p.WriteByte('>')
return nil
} | |
c21636 | err := p.Write(nil)
return err
} | |
c21637 | 1; i >= split; i-- {
if err := s.p.writeEnd(Name{Local: s.stack[i]}); err != nil {
return err
}
}
s.stack = parents[:split]
return nil
} | |
c21638 | != nil {
return err
}
}
s.stack = append(s.stack, parents...)
return nil
} | |
c21639 |
}
var content []types.ObjectContent
pc := property.DefaultCollector(client)
_ = pc.RetrieveWithFilter(ctx, []types.ManagedObjectReference{ref}, filter.Keys(), &content, filter)
return content != nil
} | |
c21640 | if len(ref) == 1 {
mref = ref[0]
}
m := ObjectManager{
ManagedObjectReference: mref,
c: client,
isVC: mref.Type == "VcenterVStorageObjectManager",
}
return &m
} | |
c21641 | },
},
},
},
ConfigSpec: &types.VirtualMachineConfigSpec{
Name: spec.Name,
DeviceChange: []types.BaseVirtualDeviceConfigSpec{
&types.VirtualDeviceConfigSpec{
Operation: types.VirtualDeviceConfigSpecOperationAdd,
FileOperation: types.VirtualDeviceConfigSpecFileOperationCreate,
... | |
c21642 | make(map[types.ManagedObjectReference]sync.Locker),
Namespace: vim25.Namespace,
Path: vim25.Path,
}
return r
} | |
c21643 | {
return reflect.TypeOf(item).Elem().Name()
} | |
c21644 | return v
}
return strings.ToLower(typeName)
} | |
c21645 | n := atomic.AddInt64(&r.counter, 1)
ref.Value = fmt.Sprintf("%s-%d", valuePrefix(ref.Type), n)
}
return ref
} | |
c21646 | r.handlers[h.Reference()] = h
r.m.Unlock()
} | |
c21647 | e := item.Entity()
if parent != nil {
e.Parent = &parent.Entity().Self
}
r.Put(item)
return item
} | |
c21648 |
defer r.m.Unlock()
return r.objects[ref]
} | |
c21649 |
if ref.Type == kind {
return val.(mo.Entity)
}
}
return nil
} | |
c21650 | if e, ok := val.(mo.Entity); ok {
entities = append(entities, e)
}
}
}
return entities
} | |
c21651 | {
handlers = append(handlers, handler)
}
r.m.Unlock()
for i := range handlers {
f(handlers[i])
}
} | |
c21652 | me.Entity().OverallStatus = types.ManagedEntityStatusGreen
me.Entity().EffectiveRole = []int32{-1} // Admin
}
r.objects[ref] = item
r.m.Unlock()
r.applyHandlers(func(o RegisterObject) {
o.PutObject(item)
})
return item
} | |
c21653 |
delete(r.objects, item)
delete(r.handlers, item)
delete(r.locks, item)
r.m.Unlock()
} | |
c21654 | }
}
val := getManagedObject(obj).Addr().Interface().(mo.Reference)
mo.ApplyPropertyChange(val, changes)
r.applyHandlers(func(o RegisterObject) {
o.UpdateObject(val, changes)
})
} | |
c21655 | := item.Entity().Parent
item = r.Get(*parent).(mo.Entity)
if item.Reference().Type == kind {
return item
}
}
} | |
c21656 | r.getEntityParent(item, "Datacenter").(*Datacenter)
} | |
c21657 | item.Reference().Type {
case "ComputeResource":
return item
case "ClusterComputeResource":
return item
}
}
} | |
c21658 | ref := range refs {
if e, ok := r.Get(ref).(mo.Entity); ok {
if name == e.Entity().Name {
return e
}
}
}
return nil
} | |
c21659 |
for _, ref := range refs {
for _, m := range match {
if ref == m {
return &ref
}
}
}
return nil
} | |
c21660 | r.WithLock(obj, func() {
*field = append(*field, ref...)
})
} | |
c21661 | {
r.WithLock(obj, func() {
if FindReference(*field, ref) == nil {
*field = append(*field, ref)
}
})
} | |
c21662 | r.Get(r.content().SearchIndex.Reference()).(*SearchIndex)
} | |
c21663 | {
return r.Get(r.content().EventManager.Reference()).(*EventManager)
} | |
c21664 | r.Get(r.content().FileManager.Reference()).(*FileManager)
} | |
c21665 | {
return r.Get(r.content().VirtualDiskManager.Reference()).(*VirtualDiskManager)
} | |
c21666 | r.Get(r.content().ViewManager.Reference()).(*ViewManager)
} | |
c21667 | {
return r.Get(r.content().UserDirectory.Reference()).(*UserDirectory)
} | |
c21668 | {
return r.Get(r.content().SessionManager.Reference()).(*SessionManager)
} | |
c21669 | {
return r.Get(r.content().Setting.Reference()).(*OptionManager)
} | |
c21670 | {
return r.Get(r.content().CustomFieldsManager.Reference()).(*CustomFieldsManager)
} | |
c21671 | reflect.ValueOf(o.Obj))
for _, p := range o.PropSet {
rv, ok := t.props[p.Name]
if !ok {
continue
}
assignValue(v, rv, reflect.ValueOf(p.Val))
}
return v, nil
} | |
c21672 | Map.SessionManager(),
sdk: make(map[string]*Registry),
}
s.client, _ = vim25.NewClient(context.Background(), s)
return s
} | |
c21673 | String: msg,
}
f.Detail.Fault = fault
return f
} | |
c21674 | if m.Type.NumOut() != 1 || m.Type.Out(0) != f { // all methods return soap.HasFault
continue
}
about.Methods = append(about.Methods, strings.Replace(m.Name, "Task", "_Task", 1))
}
}
sort.Strings(about.Methods)
sort.Strings(about.Types)
w.Header().Set("Content-Type", "application/json")
enc := json.... | |
c21675 | so we can optionally use vapi/simulator internally.
if m, ok := handler.(tagManager); ok {
s.sdk[vim25.Path].tagManager = m
}
} | |
c21676 | s.sdk[r.Path] = r
s.ServeMux.HandleFunc(r.Path, s.ServeSDK)
} | |
c21677 | = ctx.Map.content().PropertyCollector
}
res = s.call(ctx, method)
}
if f := res.Fault(); f != nil {
w.WriteHeader(http.StatusInternalServerError)
// the generated method/*Body structs use the '*soap.Fault' type,
// so we need our own Body type to use the modified '*soapFault' type.
soapBody = struct {
... | |
c21678 | _, addr := range addrs {
if ip, ok := addr.(*net.IPNet); ok && !ip.IP.IsLoopback() {
if ip.IP.To4() != nil {
return ip.IP.String()
}
}
}
}
return addr.IP.String()
} | |
c21679 |
Value: u.String(),
},
)
u.User = url.UserPassword("user", "pass")
if s.TLS != nil {
ts.TLS = s.TLS
ts.TLS.ClientAuth = tls.RequestClientCert // Used by SessionManager.LoginExtensionByCertificate
Map.SessionManager().TLSCert = func() string {
return base64.StdEncoding.EncodeToString(ts.TLS.Certificat... | |
c21680 | x509.ParseCertificate(s.TLS.Certificates[0].Certificate[0])
return cert
} | |
c21681 | := w.(http.Hijacker).Hijack()
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
go io.Copy(src, dst)
go func() {
_, _ = io.Copy(dst, src)
_ = dst.Close()
_ = src.Close()
}()
} | |
c21682 | 80 in real life)
q := s.URL.Query()
q.Set("GOVMOMI_TUNNEL_PROXY_PORT", strconv.Itoa(s.Tunnel))
s.URL.RawQuery = q.Encode()
go tunnel.Serve(l)
return nil
} | |
c21683 |
val := reflect.New(rtype).Interface()
err = decoder.DecodeElement(val, &start)
if err != nil {
return nil, fmt.Errorf("decoding %s: %s", kind, err)
}
method := &Method{Name: kind, Header: *req.Header, Body: val}
field := reflect.ValueOf(val).Elem().FieldByName("This")
method.This = field.Interface().(type... | |
c21684 | Skip root entity in building inventory path.
if me.Parent == nil {
continue
}
path += "/" + me.Name
}
paths[info.Key.Value] = path
}
return paths, nil
} | |
c21685 | if value.(*types.CustomFieldStringValue).Key == field.Key {
entity.Value = append(values[:i], values[i+1:]...)
break
}
}
cValues := e.Entity().CustomValue
for i, cValue := range cValues {
if cValue.(*types.CustomFieldStringValue).Key == field.Key {
entity.CustomValue = append(cValues[... | |
c21686 | := range aFields {
if aField.Key == field.Key {
aFields[i].Name = field.Name
break
}
}
})
}
} | |
c21687 | // ok
default:
log.Printf("unknown archive format: %q", u)
return nil, vix.Error(vix.InvalidArg)
}
return &archive{
name: u.Path,
size: math.MaxInt64,
}, nil
} | |
c21688 | return h.newArchiveToGuest(u)
default:
return nil, os.ErrNotExist
}
} | |
c21689 | {
err := h.Write(u, tw)
_ = tw.Close()
_ = c.Close()
if gzipTrailer {
_, _ = w.Write(gzipHeader)
}
_ = w.CloseWithError(err)
}()
return a, nil
} | |
c21690 |
if bytes.Equal(header, gzipHeader) {
gz, err := gzip.NewReader(a.Reader)
if err != nil {
_ = r.CloseWithError(err)
cerr = err
return
}
c = gz.Close
a.Reader = gz
}
tr := tar.NewReader(a.Reader)
cerr = h.Read(u, tr)
_ = c()
_ = r.CloseWithError(cerr)
}()
return a, nil
} | |
c21691 | err = os.Symlink(header.Linkname, name)
}
// TODO: Uid/Gid may not be meaningful here without some mapping.
// The other option to consider would be making use of the guest auth user ID.
// os.Lchown(name, header.Uid, header.Gid)
if err != nil {
return err
}
}
} | |
c21692 | == tar.TypeDir {
header.Name += "/"
}
var f *os.File
if header.Typeflag == tar.TypeReg && fi.Size() != 0 {
f, err = os.Open(filepath.Clean(file))
if err != nil {
if os.IsPermission(err) {
return nil
}
return err
}
}
_ = tw.WriteHeader(header)
if f != nil {
_, err = io.Co... | |
c21693 | strconv.ParseFloat(s, 32)
match = float32(x)
case float64:
match, _ = strconv.ParseFloat(s, 64)
case fmt.Stringer:
prop.Val = prop.Val.(fmt.Stringer).String()
default:
if ptype.Kind() != reflect.String {
return false
}
// An enum type we can convert to a string type
prop.Val = reflect.Va... | |
c21694 | return len(f) == len(props) // false if a property such as VM "guest" is unset
} | |
c21695 | {
if f.MatchPropertyList(o.PropSet) {
refs = append(refs, o.Obj)
}
}
return refs
} | |
c21696 | return l.LintFiles(map[string][]byte{filename: src})
} | |
c21697 | f.Name.Name != pkgName {
return nil, fmt.Errorf("%s is in package %s, not %s", filename, f.Name.Name, pkgName)
}
pkg.files[filename] = &file{
pkg: pkg,
f: f,
fset: pkg.fset,
src: src,
filename: filename,
}
}
if len(pkg.files) == 0 {
return nil, nil
}
return pkg.lint()... | |
c21698 | pos.Filename = f.filename
}
return f.pkg.errorfAt(pos, confidence, args...)
} | |
c21699 | the package-level scope.
pos := id.Pos()
for _, f := range p.files {
if f.f.Pos() <= pos && pos < f.f.End() {
scope = p.typesInfo.Scopes[f.f]
break
}
}
}
return scope
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.