id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c9400 |
clients: []chan *types.VmResponse{},
closeSignal: make(chan *types.VmResponse, 1),
running: !block,
lock: sync.RWMutex{},
}
if !block {
fo.start()
}
return fo
} | |
c9401 |
defer f.Close()
var s *specs.Process
if err := json.NewDecoder(f).Decode(&s); err != nil {
return nil, err
}
return s, nil
} | |
c9402 | {
err := createIfNotExists(filepath.Join(rootfs, dir), true)
if err != nil {
return err
}
}
return nil
} | |
c9403 | range nc.eth {
if v != nil {
nics = append(nics, v)
}
}
return
} | |
c9404 | = syscall.Flock(int(lockFile.Fd()), syscall.LOCK_EX)
if err != nil {
lockFile.Close()
return nil, err
}
return lockFile, nil
} | |
c9405 | syscall.LOCK_UN)
if err != nil {
return err
}
lockFile.Close()
return nil
} | |
c9406 | return fmt.Errorf("VmContext(%s): event handler already shutdown.", ctx.Id)
}
ctx.Hub <- ev
return nil
} | |
c9407 | {
b, retry, err = c.tryReadByte()
}
return
} | |
c9408 |
return
}
if retry {
// This bad rune was a beginning of telnet command. Try read next rune.
goto loop
}
// Return escaped IAC as unicode.ReplacementChar
return
} | |
c9409 | buf[n] = b
n++
if c.r.Buffered() == 0 {
// Try don't block if can return some data
break
}
}
return n, nil
} | |
c9410 | line = append(line, b)
if b == delim {
break
}
}
return line, nil
} | |
c9411 | if err != nil {
return err
}
if b == delim {
break
}
}
return nil
} | |
c9412 | := c.ReadBytes(delim)
return string(bytes), err
} | |
c9413 |
return c.readUntil(true, delims...)
} | |
c9414 | error) {
d, _, err := c.readUntil(true, delims...)
return d, err
} | |
c9415 | error) {
_, i, err := c.readUntil(false, delims...)
return i, err
} | |
c9416 | err := c.readUntil(false, delims...)
return err
} | |
c9417 |
break
}
switch buf[i] {
case LF:
k, err = c.Conn.Write([]byte{CR, LF})
case cmdIAC:
k, err = c.Conn.Write([]byte{cmdIAC, cmdIAC})
}
n += k
if err != nil {
break
}
buf = buf[i+1:]
}
return n, err
} | |
c9418 | if err != nil {
vm.Log(ERROR, "cannot associate with vm: %v", err)
return nil, err
}
vm.clients = CreateFanout(Status, 128, false)
return vm, nil
} | |
c9419 |
defer close(doneRoute)
if err := netlink.RouteSubscribe(chRoute, doneRoute); err != nil {
glog.Fatal(err)
}
for {
select {
case updateLink := <-chLink:
handleLink(updateLink, netNs2Containerd)
case updateAddr := <-chAddr:
handleAddr(updateAddr, netNs2Containerd)
case updateRoute := <-chRoute:
h... | |
c9420 | logger
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
} | |
c9421 | id,
cause: "spec error: " + cause,
}
} | |
c9422 | newline := scanner.Text()
list := strings.Fields(newline)
for _, item := range list {
if strings.EqualFold(item, "GICv2") {
return "gicv2"
} else if strings.EqualFold(item, "GICv3") ||
strings.EqualFold(item, "GICv4") {
return "gicv3"
}
}
}
return "unknown"
} | |
c9423 | hypervisor.GetVm(vmName, t.BootConfigFromTemplate(), false)
} | |
c9424 | nil {
f.Close()
return nil, fmt.Errorf("Placing LOCK_SH lock on process json file failed: %s", err.Error())
}
return &ProcessList{file: f}, nil
} | |
c9425 | json: json,
self: s,
}
kagenta.RegisterAgentServiceServer(s, jp)
healthServer := health.NewServer()
grpc_health_v1.RegisterHealthServer(s, healthServer)
return s, nil
} | |
c9426 | s, _, err := k.GetStringValue("MachineGuid")
if err != nil {
return "", err
}
return s, nil
} | |
c9427 | fmt.Errorf("machineid: %v", err)
}
return protect(appID, id), nil
} | |
c9428 | extractID(buf.String())
if err != nil {
return "", err
}
return trim(id), nil
} | |
c9429 | c.Stdout = stdout
c.Stderr = stderr
return c.Run()
} | |
c9430 | mac.Write([]byte(appID))
return hex.EncodeToString(mac.Sum(nil))
} | |
c9431 | method,
url,
data,
)
sig, err := generateSig(message, c.Secret)
if err != nil {
return nil, err
}
h["CB-ACCESS-SIGN"] = sig
return h, nil
} | |
c9432 | err
}
// TODO: Package mode here
err = f.findPackage()
if err != nil {
return nil, err
}
if f.IsInterface() || f.Mode == Package {
f.loadMethods()
}
if f.IsFunction() {
err = f.loadMethodForFunction()
if err != nil {
return nil, err
}
}
return f, nil
} | |
c9433 | }
return types.IsInterface(f.Target.Type())
} | |
c9434 |
_, ok := f.Target.Type().Underlying().(*types.Signature)
return ok
} | |
c9435 | tmpl = template.Must(template.New("fake").Funcs(functionFuncs).Parse(functionTemplate))
}
if f.Mode == Package {
log.Printf("Writing fake %s for package %s to package %s\n", f.Name, f.TargetPackage, f.DestinationPackage)
tmpl = template.Must(template.New("fake").Funcs(packageFuncs).Parse(packageTemplate))
}
i... | |
c9436 | := methods[i].Type().(*types.Signature)
if !ok {
continue
}
result = append(result, &rawMethod{
Func: fun,
Signature: sig,
})
}
return result
} | |
c9437 |
result = append(result, p[i])
}
}
return result
} | |
c9438 | } else {
params = append(params, prefix+unexport(p[i].Name))
}
}
return strings.Join(params, ", ")
} | |
c9439 |
params = append(params, p[i].Type)
}
return strings.Join(params, ", ")
} | |
c9440 |
params = append(params, unexport(p[i].Name)+" "+p[i].Type)
}
return strings.Join(params, ", ")
} | |
c9441 | params = append(params, unexport(p[i].Name))
}
}
return strings.Join(params, ", ")
} | |
c9442 | {
params = append(params, unexport(p[i].Name))
}
}
return strings.Join(params, ", ")
} | |
c9443 |
return p[0].Type
}
result := "("
for i := range p {
t := p[i].Type
if p[i].IsVariadic {
t = strings.Replace(t, "...", "[]", -1)
}
result = result + t
if i < len(p) {
result = result + ", "
}
}
result = result + ")"
return result
} | |
c9444 |
}
return fmt.Sprintf(`%s "%s"`, i.Alias, i.PkgPath)
} | |
c9445 | exists {
alias = uniqueAliasForImport(alias, i.ByAlias)
}
result := Import{Alias: alias, PkgPath: path}
i.ByPkgPath[path] = result
i.ByAlias[alias] = result
return result
} | |
c9446 | i.ByPkgPath[imports.VendorlessPath(p.Path())].Alias
} | |
c9447 | continue
}
sig, ok := obj.Type().(*types.Signature)
if !ok {
continue
}
result = append(result, &rawMethod{
Func: fun,
Signature: sig,
})
}
return result
} | |
c9448 | t.Obj().Pkg().Path())
}
case *types.Slice:
f.addImportsFor(t.Elem())
case *types.Array:
f.addImportsFor(t.Elem())
case *types.Interface:
return
case *types.Signature:
f.addTypesForMethod(t)
default:
log.Printf("!!! WARNING: Missing case for type %s\n", reflect.TypeOf(typ).String())
}
} | |
c9449 | } else {
rets = append(rets, p+unexport(r[i].Name))
}
}
return strings.Join(rets, ", ")
} | |
c9450 |
rets = append(rets, r[i].Type)
}
return strings.Join(rets, ", ")
} | |
c9451 |
rets = append(rets, unexport(r[i].Name)+" "+r[i].Type)
}
return strings.Join(rets, ", ")
} | |
c9452 |
rets = append(rets, unexport(r[i].Name))
}
return strings.Join(rets, ", ")
} | |
c9453 | + r[i].Type
if i < len(r) {
result = result + ", "
}
}
result = result + ")"
return result
} | |
c9454 |
pks: map[peer.ID]ic.PubKey{},
sks: map[peer.ID]ic.PrivKey{},
}
} | |
c9455 | return nil, err
}
peerMetadata, err := NewPeerMetadata(ctx, store, opts)
if err != nil {
return nil, err
}
ps := pstore.NewPeerstore(keyBook, addrBook, peerMetadata)
return ps, nil
} | |
c9456 |
if len(idset) == 0 {
return peer.IDSlice{}, nil
}
ids := make(peer.IDSlice, 0, len(idset))
for id := range idset {
pid, _ := base32.RawStdEncoding.DecodeString(id)
id, _ := peer.IDFromBytes(pid)
ids = append(ids, id)
}
return ids, nil
} | |
c9457 | !found {
m.latmap[p] = next // when no data, just take it as the mean.
} else {
nextf = ((1.0 - s) * ewmaf) + (s * nextf)
m.latmap[p] = time.Duration(nextf)
}
m.latmu.Unlock()
} | |
c9458 |
m.latmu.RLock()
lat := m.latmap[p]
m.latmu.RUnlock()
return time.Duration(lat)
} | |
c9459 | ma.NewMultiaddr("/ip4/123.123.123.123/tcp/7001")
return &ProtoAddr{Multiaddr: a}
} | |
c9460 | := pt.RandPeerID()
return &ProtoPeerID{ID: id}
} | |
c9461 | select {
case <-ticker.C:
mab.gc()
case <-mab.ctx.Done():
return
}
}
} | |
c9462 | {
delete(amap, k)
}
}
if len(amap) == 0 {
delete(mab.addrs, p)
}
}
} | |
c9463 | := time.Now().Add(newTTL)
for k, addr := range amap {
if oldTTL == addr.TTL {
addr.TTL = newTTL
addr.Expires = exp
amap[k] = addr
}
}
} | |
c9464 | defer mab.addrmu.Unlock()
delete(mab.addrs, p)
} | |
c9465 |
subs[i] = subs[len(subs)-1]
subs[len(subs)-1] = nil
mgr.subs[p] = subs[:len(subs)-1]
return
}
}
} | |
c9466 | mgr.subs[p]; ok {
for _, sub := range subs {
sub.pubAddr(addr)
}
}
} | |
c9467 | outch <- next:
if len(buffer) > 0 {
next = buffer[0]
buffer = buffer[1:]
} else {
outch = nil
next = nil
}
case naddr := <-sub.pubch:
if sent[string(naddr.Bytes())] {
continue
}
sent[string(naddr.Bytes())] = true
if next == nil {
next = naddr
outch = o... | |
c9468 | kb,
AddrBook: ab,
PeerMetadata: md,
Metrics: NewMetrics(),
internedProtocols: make(map[string]string),
}
} | |
c9469 | var lookaheadCh <-chan time.Time
if gc.lookaheadEnabled {
lookaheadTimer := time.NewTicker(gc.ab.opts.GCLookaheadInterval)
lookaheadCh = lookaheadTimer.C
gc.populateLookahead() // do a lookahead now
defer lookaheadTimer.Stop()
}
for {
select {
case <-purgeTimer.C:
gc.purgeFunc()
case <-lookaheadC... | |
c9470 | }
if err = write.Put(key, data); err != nil {
return err
}
// write succeeded; record is no longer dirty.
r.dirty = false
return nil
} | |
c9471 | ab.AddAddrs(p, []ma.Multiaddr{addr}, ttl)
} | |
c9472 |
if ttl <= 0 {
return
}
addrs = cleanAddrs(addrs)
ab.setAddrs(p, addrs, ttl, ttlExtend)
} | |
c9473 | ab.SetAddrs(p, []ma.Multiaddr{addr}, ttl)
} | |
c9474 | {
ab.deleteAddrs(p, addrs)
return
}
ab.setAddrs(p, addrs, ttl, ttlOverride)
} | |
c9475 |
for _, entry := range pr.Addrs {
if entry.Ttl != int64(oldTTL) {
continue
}
entry.Ttl, entry.Expiry = int64(newTTL), newExp
pr.dirty = true
}
if pr.clean() {
pr.flush(ab.ds)
}
} | |
c9476 | pr.RLock()
defer pr.RUnlock()
addrs := make([]ma.Multiaddr, 0, len(pr.Addrs))
for _, a := range pr.Addrs {
addrs = append(addrs, a.Addr)
}
return addrs
} | |
c9477 | string {
return ds.RawKey(result.Key).Name()
})
if err != nil {
log.Errorf("error while retrieving peers with addresses: %v", err)
}
return ids
} | |
c9478 |
if err := ab.ds.Delete(key); err != nil {
log.Errorf("failed to clear addresses for peer %s: %v", p.Pretty(), err)
}
} | |
c9479 | := &ChanQueue{Queue: pq}
cq.process(ctx)
return cq
} | |
c9480 | value := range queryParams {
params.Add(key, value)
}
return baseURL + params.Encode()
} | |
c9481 | value := range request.Headers {
req.Header.Set(key, value)
}
_, exists := req.Header["Content-Type"]
if len(request.Body) > 0 && !exists {
req.Header.Set("Content-Type", "application/json")
}
return req, err
} | |
c9482 | DefaultClient.HTTPClient.Do(req)
} | |
c9483 | Headers: res.Header,
}
res.Body.Close() // nolint
return &response, err
} | |
c9484 | {
return c.HTTPClient.Do(req)
} | |
c9485 | and make the request.
res, err := c.MakeRequest(req)
if err != nil {
return nil, err
}
// Build Response object.
return BuildResponse(res)
} | |
c9486 |
}
}
res.Text = text[res.Index:end]
// apply rules
if p.options.MatchByOrder {
sort.Sort(rules.MatchByOrder(matches))
}
ctx := &rules.Context{Text: res.Text}
applied := false
for _, applier := range matches {
ok, err := applier.Apply(ctx, p.options, res.Time)
if err != nil {
return nil, err
}
... | |
c9487 | append(p.rules, r...)
} | |
c9488 | = append(p.middleware, f...)
} | |
c9489 | defaultOptions}
}
return &Parser{options: o}
} | |
c9490 |
options.WindowBuckets = DefaultWindowBuckets
}
return &Breaker{
BackOff: options.BackOff,
Clock: options.Clock,
ShouldTrip: options.ShouldTrip,
nextBackOff: options.BackOff.NextBackOff(),
counts: newWindow(options.WindowTime, options.WindowBuckets),
}
} | |
c9491 | ShouldTrip: RateTripFunc(rate, minSamples),
})
} | |
c9492 |
for v := range eventReader {
select {
case output <- v:
default:
<-output
output <- v
}
}
}()
cb.eventReceivers = append(cb.eventReceivers, eventReader)
return output
} | |
c9493 | = append(cb.listeners, listener)
} | |
c9494 | cb.listeners = append(cb.listeners[:i], cb.listeners[i+1:]...)
return true
}
}
return false
} | |
c9495 | cb.consecFailures, 0)
cb.counts.Reset()
} | |
c9496 | cb.sendEvent(BreakerFail)
if cb.ShouldTrip != nil && cb.ShouldTrip(cb) {
cb.Trip()
}
} | |
c9497 |
cb.sendEvent(BreakerReady)
}
return state == closed || state == halfopen
} | |
c9498 | cb.CallContext(context.Background(), circuit, timeout)
} | |
c9499 | := <-c:
err = e
case <-cb.Clock.After(timeout):
err = ErrBreakerTimeout
}
}
if err != nil {
if ctx.Err() != context.Canceled {
cb.Fail()
}
return err
}
cb.Success()
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.