id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c170300 | dc.InventoryPath + "/" + string(p)
} | |
c170301 |
return p.RootFromDatacenter(dc) + "/" + relative
} | |
c170302 | return inventoryPath, fmt.Errorf("could not split path %q on %q", inventoryPath, p.Delimiter())
}
return s[0], nil
} | |
c170303 | {
return inventoryPath, err
}
return path.Dir(relative), nil
} | |
c170304 | != nil {
return inventoryPath, err
}
return fmt.Sprintf("%s/%s", dcPath, newParticle), nil
} | |
c170305 | {
return "", err
}
return RootPathParticleHost.SplitDatacenter(hs.InventoryPath)
} | |
c170306 |
if err != nil {
return "", err
}
return RootPathParticleHost.NewRootFromPath(hs.InventoryPath, RootPathParticleDatastore)
} | |
c170307 | return nil, fmt.Errorf("%q is not a datastore folder", folder.InventoryPath)
}
return folder, nil
} | |
c170308 | return nil, fmt.Errorf("%q is not a host folder", folder.InventoryPath)
}
return folder, nil
} | |
c170309 | VM folder", folder.InventoryPath)
}
log.Printf("[DEBUG] Folder located: %q", folder.InventoryPath)
return folder, nil
} | |
c170310 | return nil, fmt.Errorf("%q is not a network folder", folder.InventoryPath)
}
return folder, nil
} | |
c170311 | }
return strings.TrimPrefix(path.Clean(p), "/")
} | |
c170312 | err
}
tctx, tcancel := context.WithTimeout(context.Background(), provider.DefaultAPITimeout)
defer tcancel()
return task.Wait(tctx)
} | |
c170313 | err := folder.Properties(ctx, folder.Reference(), nil, &props); err != nil {
return nil, err
}
return &props, nil
} | |
c170314 | props.ChildType[1]
}
switch ct {
case "Datacenter":
ft = VSphereFolderTypeDatacenter
case "ComputeResource":
ft = VSphereFolderTypeHost
case "VirtualMachine":
ft = VSphereFolderTypeVM
case "Datastore":
ft = VSphereFolderTypeDatastore
case "Network":
ft = VSphereFolderTypeNetwork
default:
return ft, fmt.Errorf("unknown folder type: %#v", ct)
}
return ft, nil
} | |
c170315 | := gophercloud.BuildQueryString(opts)
return q.String(), err
} | |
c170316 | v == t {
return i
}
}
return -1
} | |
c170317 | if f(v) {
return true
}
}
return false
} | |
c170318 | err := google.JWTConfigFromJSON(key, compute.ComputeScope)
if err != nil {
return nil, err
}
return jwtConfig.Client(oauth2.NoContext), nil
} | |
c170319 | err := http.DefaultClient.Do(req)
if err != nil {
return "", err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return "", fmt.Errorf("discover-gce: invalid status code %d when fetching project id", resp.StatusCode)
}
project, err := ioutil.ReadAll(resp.Body)
if err != nil {
return "", err
}
return string(project), nil
} | |
c170320 | v := range page.Items {
zones = append(zones, v.Name)
}
return nil
}
if err := call.Pages(oauth2.NoContext, f); err != nil {
return nil, err
}
return zones, nil
} | |
c170321 | addrs = append(addrs, v.NetworkInterfaces[0].NetworkIP)
break
}
}
}
return nil
}
call := svc.Instances.List(project, zone)
if err := call.Pages(oauth2.NoContext, f); err != nil {
return nil, err
}
return addrs, nil
} | |
c170322 | opts {
if err := opt(d); err != nil {
return nil, err
}
}
d.once.Do(d.initProviders)
return d, nil
} | |
c170323 |
d.userAgent = agent
return nil
}
} | |
c170324 | {
return func(d *Discover) error {
d.Providers = m
return nil
}
} | |
c170325 | names = append(names, n)
}
sort.Strings(names)
return names
} | |
c170326 | h = append(h, d.Providers[name].Help())
}
return strings.Join(h, "\n")
} | |
c170327 | nil, fmt.Errorf("discover: unknown provider " + name)
}
l.Printf("[DEBUG] discover: Using provider %q", name)
if typ, ok := p.(ProviderWithUserAgent); ok {
typ.SetUserAgent(d.userAgent)
return p.Addrs(args, l)
}
return p.Addrs(args, l)
} | |
c170328 |
quote := func(s string) string {
if strings.ContainsAny(s, ` "\`) {
return strconv.Quote(s)
}
return s
}
var vals []string
for _, k := range keys {
v := c[k]
if v == "" {
continue
}
vals = append(vals, quote(k)+"="+quote(v))
}
return strings.Join(vals, " ")
} | |
c170329 | = pod.Status.HostIP
}
if addr == "" {
// This can be empty according to the API docs, so we protect that.
l.Printf("[DEBUG] discover-k8s: ignoring pod %q, requested IP is empty", pod.Name)
continue
}
// We only use the port if it is specified as an annotation. The
// annotation value can be a name or a number.
if v := pod.Annotations[AnnotationKeyPort]; v != "" {
port, err := podPort(&pod, v, hostNetwork)
if err != nil {
l.Printf("[DEBUG] discover-k8s: ignoring pod %q, error retrieving port: %s",
pod.Name, err)
continue
}
addr = fmt.Sprintf("%s:%d", addr, port)
}
addrs = append(addrs, addr)
}
return addrs, nil
} | |
c170330 | {
return value
}
return os.Getenv(env)
} | |
c170331 | to parse timeout: %s", err)
}
} else {
params.Timeout = 5 * time.Second
}
// validate and set v6 toggle
if args["v6"] != "" {
if v6, err = strconv.ParseBool(args["v6"]); err != nil {
return nil, fmt.Errorf("discover-mdns: Failed to parse v6: %s", err)
}
} else {
v6 = true
}
// validate and set v4 toggle
if args["v4"] != "" {
if v4, err = strconv.ParseBool(args["v4"]); err != nil {
return nil, fmt.Errorf("discover-mdns: Failed to parse v4: %s", err)
}
} else {
v4 = true
}
// init entries channel
ch = make(chan *m.ServiceEntry)
defer close(ch)
params.Entries = ch
// build addresses
go func() {
var addr string
for e := range ch {
addr = "" // reset addr each loop
if v6 && e.AddrV6 != nil {
addr = net.JoinHostPort(e.AddrV6.String(),
strconv.Itoa(e.Port))
}
if addr == "" && v4 && e.AddrV4 != nil {
addr = net.JoinHostPort(e.AddrV4.String(),
strconv.Itoa(e.Port))
}
if addr != "" {
l.Printf("[DEBUG] discover-mdns: %s -> %s",
e.Host, addr)
// build address list
addrs = append(addrs, addr)
}
}
}()
// lookup and return
return addrs, m.Query(params)
} | |
c170332 | logger = log.New(ioutil.Discard, "", 0)
}
} | |
c170333 | 1 {
s = fmt.Sprintf(format, a...)
} else {
s = format
}
return fmt.Errorf("discover-vsphere: %s", s)
} | |
c170334 | v
}
if v := os.Getenv(env); v != "" {
logger.Printf("[DEBUG] Using value of %s for configuration of %s", env, key)
return v
}
return ""
} | |
c170335 | err
}
client.TagsClient, err = newRestSession(ctx, u, insecure)
if err != nil {
return nil, err
}
logger.Println("[DEBUG] All vSphere client endpoints connected successfully")
return client, nil
} | |
c170336 | fmt.Errorf("error setting up new vSphere SOAP client: %s", err)
}
logger.Println("[DEBUG] SOAP API session creation successful")
return client, nil
} | |
c170337 | nil, fmt.Errorf("error connecting to CIS REST endpoint: %s", err)
}
logger.Println("[DEBUG] CIS REST API session creation successful")
return client, nil
} | |
c170338 | return nil, discoverErr("both tag_name and category_name must be specified")
}
logger.Printf("[INFO] Locating all virtual machine IP addresses with tag %q in category %q", tagName, categoryName)
tagID, err := tagIDFromName(ctx, client.TagsClient, tagName, categoryName)
if err != nil {
return nil, discoverErr(err.Error())
}
addrs, err := virtualMachineIPsForTag(ctx, client, tagID)
if err != nil {
return nil, discoverErr(err.Error())
}
logger.Printf("[INFO] Final IP address list: %s", strings.Join(addrs, ","))
return addrs, nil
} | |
c170339 | ID for tag name %q and category %q", name, category)
categoryID, err := tagCategoryByName(ctx, client, category)
if err != nil {
return "", err
}
return tagByName(ctx, client, name, categoryID)
} | |
c170340 | // are unique, empirical observation via the console and API show that they
// are. This error case is handled anyway.
return "", fmt.Errorf("multiple categories with name %q found", name)
}
return cats[0].ID, nil
} | |
c170341 | // docs even say that tags need to be unique in categories, yet
// GetTagByNameForCategory still returns multiple results.
return "", fmt.Errorf("multiple tags with name %q found", name)
}
logger.Printf("[DEBUG] Tag ID is %q", tids[0].ID)
return tids[0].ID, nil
} | |
c170342 |
vms, err := virtualMachinesForTag(ctx, client, id)
if err != nil {
return nil, err
}
return ipAddrsForVirtualMachines(ctx, client, vms)
} | |
c170343 | Discovered object ID %q is not a virutal machine", *obj.ID)
continue
}
vm, err := virtualMachineFromMOID(ctx, client.VimClient, *obj.ID)
if err != nil {
return nil, fmt.Errorf("error locating virtual machine with ID %q: %s", *obj.ID, err)
}
vms = append(vms, vm)
}
logger.Printf("[DEBUG] Discovered virtual machines: %s", virtualMachineNames(vms))
return vms, nil
} | |
c170344 | vm)
if err != nil {
return nil, err
}
addrs = append(addrs, as...)
}
return addrs, nil
} | |
c170345 | to return here. If our reference returned here and is not a
// VM, then we have bigger problems and to be honest we should be panicking
// anyway.
return vm.(*object.VirtualMachine), nil
} | |
c170346 | mo.VirtualMachine
if err := vm.Properties(ctx, vm.Reference(), keys, &props); err != nil {
return nil, err
}
return &props, nil
} | |
c170347 | No networking stack information available for %q or VMware tools not running", vm.Name())
return nil, nil
}
// Now fetch all IP addresses, checking at the same time to see if the IP
// address is eligible to be a primary IP address.
for _, n := range props.Guest.Net {
if n.IpConfig != nil {
for _, addr := range n.IpConfig.IpAddress {
if skipIPAddr(net.ParseIP(addr.IpAddress)) {
continue
}
addrs = append(addrs, addr.IpAddress)
}
}
}
logger.Printf("[INFO] Discovered IP addresses for virtual machine %q: %s", vm.Name(), strings.Join(addrs, ","))
return addrs, nil
} | |
c170348 | fallthrough
case ip.IsMulticast():
return true
}
return false
} | |
c170349 | {
s = append(s, vm.Name())
}
return strings.Join(s, ",")
} | |
c170350 | return LoggerInvoker(v)
case func(http.ResponseWriter, *http.Request):
return handlerFuncInvoker(v)
case func(http.ResponseWriter, error):
return internalServerErrorInvoker(v)
}
}
return h
} | |
c170351 | h = validateAndWrapHandler(h)
if wrapper != nil && !inject.IsFastInvoker(h) {
h = wrapper(h)
}
wrappedHandlers[i] = h
}
return wrappedHandlers
} | |
c170352 |
m.Map(m.logger)
m.Map(defaultReturnHandler())
m.NotFound(http.NotFound)
m.InternalServerError(func(rw http.ResponseWriter, err error) {
http.Error(rw, err.Error(), 500)
})
return m
} | |
c170353 | = make([]Handler, 0)
for _, handler := range handlers {
m.Use(handler)
}
} | |
c170354 | m.handlers = append(m.handlers, handler)
} | |
c170355 | := range m.befores {
if h(rw, req) {
return
}
}
m.Router.ServeHTTP(rw, req)
} | |
c170356 | prefix
m.hasURLPrefix = len(m.urlPrefix) > 0
} | |
c170357 | *ini.File, err error) {
cfg, err = ini.Load(source, others...)
return Config(), err
} | |
c170358 | err := rb.Bytes()
return string(data), err
} | |
c170359 | := strings.LastIndex(addr, ":"); i > -1 {
addr = addr[:i]
}
}
}
return addr
} | |
c170360 | ...interface{}) {
ctx.renderHTML(status, DEFAULT_TPL_SET_NAME, name, data...)
} | |
c170361 |
ctx.renderHTML(status, setName, tplName, data...)
} | |
c170362 |
return ctx.Req.Form.Get(name)
} | |
c170363 | strings.TrimSpace(ctx.Query(name))
} | |
c170364 |
vals, ok := ctx.Req.Form[name]
if !ok {
return []string{}
}
return vals
} | |
c170365 | template.HTMLEscapeString(ctx.Query(name))
} | |
c170366 | _ := strconv.ParseBool(ctx.Query(name))
return v
} | |
c170367 | com.StrTo(ctx.Query(name)).MustInt()
} | |
c170368 | com.StrTo(ctx.Query(name)).MustInt64()
} | |
c170369 | := strconv.ParseFloat(ctx.Query(name), 64)
return v
} | |
c170370 | "*" && !strings.HasPrefix(name, ":") {
name = ":" + name
}
ctx.params[name] = val
} | |
c170371 | *multipart.FileHeader, error) {
return ctx.Req.FormFile(name)
} | |
c170372 | os.OpenFile(savePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
if err != nil {
return err
}
defer fw.Close()
_, err = io.Copy(fw, fr)
return err
} | |
c170373 | ""
}
val, _ := url.QueryUnescape(cookie.Value)
return val
} | |
c170374 | com.StrTo(ctx.GetCookie(name)).MustInt()
} | |
c170375 | com.StrTo(ctx.GetCookie(name)).MustInt64()
} | |
c170376 | _ := strconv.ParseFloat(ctx.GetCookie(name), 64)
return v
} | |
c170377 | ...interface{}) {
ctx.SetSuperSecureCookie(defaultCookieSecret, name, value, others...)
} | |
c170378 | ctx.GetSuperSecureCookie(defaultCookieSecret, key)
} | |
c170379 | 16, sha256.New)
text, err := com.AESGCMEncrypt(key, []byte(value))
if err != nil {
panic("error encrypting cookie: " + err.Error())
}
ctx.SetCookie(name, hex.EncodeToString(text), others...)
} | |
c170380 | key := pbkdf2.Key([]byte(secret), []byte(secret), 1000, 16, sha256.New)
text, err = com.AESGCMDecrypt(key, text)
return string(text), err == nil
} | |
c170381 | modtime = v
}
}
ctx.setRawContentHeader()
http.ServeContent(ctx.Resp, ctx.Req.Request, name, modtime, r)
} | |
c170382 | Server Error", 500)
} else {
http.Error(ctx.Resp, err.Error(), 500)
}
return
}
defer f.Close()
ctx.setRawContentHeader()
http.ServeContent(ctx.Resp, ctx.Req.Request, name, time.Now(), f)
} | |
c170383 | ctx.Resp.Header().Set("Expires", "0")
ctx.Resp.Header().Set("Cache-Control", "must-revalidate")
ctx.Resp.Header().Set("Pragma", "public")
http.ServeFile(ctx.Resp, ctx.Req.Request, file)
} | |
c170384 | !filepath.IsAbs(newPath) {
newPath = filepath.Join(Root, newPath)
}
*dir = http.Dir(newPath)
statics.Set(dir)
}
} | |
c170385 | pattern = strings.Replace(pattern, ":string", "([\\w]+)", 1)
default:
return wildcard, strings.Replace(pattern, wildcard, `(.+)`, 1)
}
}
// Cut out placeholder directly.
return wildcard, pattern[:pos[0]] + pattern[pos[1]:]
} | |
c170386 | break
}
closeIdx := strings.Index(rawPattern, ")")
if closeIdx > -1 {
rawPattern = rawPattern[:startIdx] + rawPattern[closeIdx+1:]
}
}
return rawPattern
} | |
c170387 | com.ToStr(i))
} else if pairs[i][0] != ':' && pairs[i] != "*" && pairs[i] != "*.*" {
pairs[i] = ":" + pairs[i]
}
urlPath = strings.Replace(urlPath, pairs[i], pairs[i+1], 1)
}
return urlPath
} | |
c170388 |
rm.routes[m] = make(map[string]*Leaf)
}
return rm
} | |
c170389 | defer rm.lock.RUnlock()
return rm.routes[method][pattern]
} | |
c170390 | defer rm.lock.Unlock()
rm.routes[method][pattern] = leaf
} | |
c170391 | with given name already exists: " + name)
}
r.router.namedRoutes[name] = r.leaf
} | |
c170392 | = true
}
} else {
methods[method] = true
}
// Add to router tree.
for m := range methods {
if t, ok := r.routers[m]; ok {
leaf = t.Add(pattern, handle)
} else {
t := NewTree()
leaf = t.Add(pattern, handle)
r.routers[m] = t
}
r.add(m, pattern, leaf)
}
return &Route{r, leaf}
} | |
c170393 | func(resp http.ResponseWriter, req *http.Request, params Params) {
c := r.m.createContext(resp, req)
c.params = params
c.handlers = make([]Handler, 0, len(r.m.handlers)+len(handlers))
c.handlers = append(c.handlers, r.m.handlers...)
c.handlers = append(c.handlers, handlers...)
c.run()
})
} | |
c170394 | &ComboRouter{r, pattern, h, map[string]bool{}, nil}
} | |
c170395 |
c := r.m.createContext(rw, req)
c.handlers = make([]Handler, 0, len(r.m.handlers)+len(handlers))
c.handlers = append(c.handlers, r.m.handlers...)
c.handlers = append(c.handlers, handlers...)
c.run()
}
} | |
c170396 |
r.internalServerError = func(c *Context, err error) {
c.index = 0
c.handlers = handlers
c.Map(err)
c.run()
}
} | |
c170397 | name does not exists: " + name)
}
return leaf.URLPath(pairs...)
} | |
c170398 | == nil {
panic("no corresponding route to be named")
}
cr.lastRoute.Name(name)
} | |
c170399 | &responseWriter{method, rw, 0, 0, nil}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.