id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c11400 | !ValidCode(dm.Code) {
return Multihash{}, ErrUnknownCode
}
return Multihash(buf), nil
} | |
c11401 | := &DecodedMultihash{
Code: code,
Name: Codes[code],
Length: int(length),
Digest: buf,
}
if len(dm.Digest) != dm.Length {
return nil, ErrInconsistentLen{dm}
}
return dm, nil
} | |
c11402 | ErrSumNotSupported
}
d, err := hashFunc(data, length)
if err != nil {
return nil, err
}
if length >= 0 {
d = d[:length]
}
return Encode(d, code)
} | |
c11403 | func for code %v already registered", code)
}
funcTable[code] = hashFunc
return nil
} | |
c11404 | 0
s.width = 0
s.accept = nil
} | |
c11405 | := utf8.DecodeRuneInString(s.buf[s.pos:])
s.width = w
s.pos += s.width
return r
} | |
c11406 |
r := s.buf[s.pos:]
s.buf = l + r
} | |
c11407 | s.scanRbrack(r):
return tokenRbrack
case s.scanIdent(r):
return tokenIdent
}
return tokenIllegal
} | |
c11408 | s.unread()
break loop
}
if s.scanEscaped(r) {
s.skip()
continue
}
if !s.accept(r, s.pos-s.start) {
s.unread()
break loop
}
}
return true
} | |
c11409 | return false
}
if r == '$' {
if s.read() == '{' {
return true
}
s.unread()
}
return false
} | |
c11410 |
if s.mode&scanRbrack == 0 {
return false
}
return r == '}'
} | |
c11411 | if r != '\\' {
return false
}
switch s.peek() {
case '/', '\\':
return true
default:
return false
}
} | |
c11412 | = new(scanner)
return t.Parse(buf)
} | |
c11413 |
t.Root, err = t.parseAny()
return t, err
} | |
c11414 | switch t.scanner.scan() {
case tokenLbrack:
return t.parseFunc()
case tokenIdent:
return newTextNode(
t.scanner.string(),
), nil
default:
return nil, ErrBadSubstitution
}
} | |
c11415 | '-', '?', '+':
return t.parseDefaultFunc(name)
default:
return t.parseSubstrFunc(name)
}
} | |
c11416 | tokenRbrack {
return ErrBadSubstitution
}
return nil
} | |
c11417 | strconv.Itoa(len(s))
} | |
c11418 | n := utf8.DecodeRuneInString(s)
return string(unicode.ToLower(r)) + s[n:]
} | |
c11419 | n := utf8.DecodeRuneInString(s)
return string(unicode.ToUpper(r)) + s[n:]
} | |
c11420 | {
if len(s) == 0 && len(args) == 1 {
s = args[0]
}
return s
} | |
c11421 |
if err != nil {
// bash returns the string if the length
// cannot be parsed.
return s
}
if pos+length >= len(s) {
// if the position exceeds the length of the
// string just return the rest of it like bash
return s[pos:]
}
return s[pos : pos+length]
} | |
c11422 | "", -1)
default:
return strings.Replace(s, args[0], args[1], -1)
}
} | |
c11423 | args[0], "", 1)
default:
return strings.Replace(s, args[0], args[1], 1)
}
} | |
c11424 | {
return strings.Replace(s, args[0], args[1], 1)
}
return s
} | |
c11425 | s = strings.TrimSuffix(s, args[0])
s = s + args[1]
}
return s
} | |
c11426 |
t.tree, err = parse.Parse(s)
if err != nil {
return nil, err
}
return t, nil
} | |
c11427 | s.mapper = mapping
s.writer = b
err = t.eval(s)
if err != nil {
return
}
return b.String(), nil
} | |
c11428 | case "/%":
return replaceSuffix
case "/":
return replaceFirst
case "//":
return replaceAll
case "=", ":=", ":-":
return toDefault
case ":?", ":+", "-", "+":
return toDefault
default:
return toDefault
}
} | |
c11429 | found && time.Now().Before(bp.until) {
return true
}
return false
} | |
c11430 |
defer db.lock.Unlock()
db.init()
delete(db.entries, p)
} | |
c11431 |
conn, err := s.dial(ctx, p)
if err != nil {
conn = s.bestConnToPeer(p)
if conn != nil {
// Hm? What error?
// Could have canceled the dial because we received a
// connection or some other random reason.
// Just ignore the error and return the connection.
log.Debugf("ignoring dial error because we... | |
c11432 |
goodAddrsChan <- a
}
close(goodAddrsChan)
/////////
// try to get a connection to any addr
connC, dialErr := s.dialAddrs(ctx, p, goodAddrsChan)
if dialErr != nil {
logdial["error"] = dialErr.Cause.Error()
if dialErr.Cause == context.Canceled {
// always prefer the "context canceled" error.
// we rel... | |
c11433 |
s.limiter.AddDialJob(&dialJob{
addr: a,
peer: p,
resp: resp,
ctx: ctx,
})
} | |
c11434 | dials instead of queuing up a goroutine.
if next.cancelled() {
dl.freePeerToken(next)
continue
}
dl.fdConsuming++
// we already have activePerPeer token at this point so we can just dial
go dl.executeDial(next)
return
}
} | |
c11435 |
log.Debugf("[limiter] adding a dial job through limiter: %v", dj.addr)
dl.addCheckPeerLimit(dj)
} | |
c11436 | <- dialResult{Conn: con, Addr: j.addr, Err: err}:
case <-j.ctx.Done():
if err == nil {
con.Close()
}
}
} | |
c11437 | for _, p := range protocols {
transport, ok := s.transports.m[p.Code]
if !ok {
continue
}
if transport.Proxy() {
return transport
}
}
return s.transports.m[protocols[len(protocols)-1].Code]
} | |
c11438 | fmt.Sprintf("unknown (%d)", p)
}
registered = append(registered, name)
}
}
if len(registered) > 0 {
return fmt.Errorf(
"transports already registered for protocol(s): %s",
strings.Join(registered, ", "),
)
}
for _, p := range protocols {
s.transports.m[p] = t
}
return nil
} | |
c11439 | log.Errorf("swarm listener accept error: %s", err)
}
return
}
log.Debugf("swarm listener accepted connection: %s", c)
s.refs.Add(1)
go func() {
defer s.refs.Done()
_, err := s.addConn(c, inet.DirInbound)
if err != nil {
// Probably just means that the swarm has been closed.
... | |
c11440 | &DialSync{
dials: make(map[peer.ID]*activeDial),
dialFunc: dfn,
}
} | |
c11441 | {
return ds.getActiveDial(p).wait(ctx)
} | |
c11442 | if ad, ok := ds.dials[p]; ok {
ad.cancel()
}
} | |
c11443 | // We only get an error here when the swarm is closed or closing.
if err != nil {
return
}
if h := c.swarm.StreamHandler(); h != nil {
h(s)
}
}()
}
}()
} | |
c11444 | nil, err
}
return c.addStream(ts, inet.DirOutbound)
} | |
c11445 | range c.streams.m {
streams = append(streams, s)
}
return streams
} | |
c11446 | {
s.state.Lock()
switch s.state.v {
case streamCloseWrite:
s.state.v = streamCloseBoth
s.remove()
case streamOpen:
s.state.v = streamCloseRead
}
s.state.Unlock()
}
return n, err
} | |
c11447 | s.conn.swarm.bwc.LogSentMessage(int64(n))
s.conn.swarm.bwc.LogSentMessageStream(int64(n), s.Protocol(), s.Conn().RemotePeer())
}
return n, err
} | |
c11448 |
case streamOpen:
s.state.v = streamCloseWrite
}
s.state.Unlock()
return err
} | |
c11449 | {
case streamOpen, streamCloseRead, streamCloseWrite:
s.state.v = streamReset
s.remove()
}
s.state.Unlock()
return err
} | |
c11450 | s.listeners.m = make(map[transport.Listener]struct{})
s.transports.m = make(map[int]transport.Transport)
s.notifs.m = make(map[inet.Notifiee]struct{})
s.dsync = NewDialSync(s.doDial)
s.limiter = newDialLimiter(s.dialAddr)
s.proc = goprocessctx.WithContextAndTeardown(ctx, s.teardown)
s.ctx = goprocessctx.OnClosi... | |
c11451 | err
}
s.Filters.AddDialFilter(m)
return nil
} | |
c11452 | := s.connh.Load().(inet.ConnHandler)
return handler
} | |
c11453 |
s.streamh.Store(handler)
} | |
c11454 | := s.streamh.Load().(inet.StreamHandler)
return handler
} | |
c11455 | return nil, inet.ErrNoConn
}
if dials >= DialAttempts {
return nil, errors.New("max dial attempts exceeded")
}
dials++
var err error
c, err = s.dialPeer(ctx, p)
if err != nil {
return nil, err
}
}
s, err := c.NewStream()
if err != nil {
if c.conn.IsClosed() {
continue
... | |
c11456 |
conns := s.conns.m[p]
output := make([]inet.Conn, len(conns))
for i, c := range conns {
output[i] = c
}
return output
} | |
c11457 | soon anyways.
continue
}
c.streams.Lock()
cLen := len(c.streams.m)
c.streams.Unlock()
if cLen >= bestLen {
best = c
bestLen = cLen
}
}
return best
} | |
c11458 | {
for _, c := range cs {
conns = append(conns, c)
}
}
return conns
} | |
c11459 | err := <-errCh
if err != nil {
errs = append(errs, err.Error())
}
}
if len(errs) > 0 {
return fmt.Errorf("when disconnecting from peer %s: %s", p, strings.Join(errs, ", "))
}
return nil
}
} | |
c11460 | range s.conns.m {
peers = append(peers, p)
}
return peers
} | |
c11461 | go func(f inet.Notifiee) {
defer wg.Done()
notify(f)
}(f)
}
wg.Wait()
s.notifs.RUnlock()
} | |
c11462 | := range s.listeners.m {
addrs = append(addrs, l.Multiaddr())
}
return addrs
} | |
c11463 | new(sync.WaitGroup),
routinesCount: 0,
connections: make(map[net.Conn]bool),
}
} | |
c11464 | s.lcsmu.RUnlock()
return s.routinesCount
} | |
c11465 | return lookupErr
}
return syscall.Exec(binary, command, env)
} | |
c11466 | expandPath(provider)
if provider == "" {
return "", fmt.Errorf("Could not resolve a provider!")
}
_, err := os.Stat(provider)
if err != nil {
return "", err
}
return provider, nil
} | |
c11467 | = &stdErr
err := cmd.Run()
if err != nil {
errstr := err.Error()
if stdErr.Len() > 0 {
errstr += ": " + strings.TrimSpace(stdErr.String())
}
return "", fmt.Errorf(errstr)
}
return strings.TrimSpace(stdOut.String()), nil
} | |
c11468 | := f.Name()
tf.files = append(tf.files, name)
return name
} | |
c11469 | it's not DEVSHM
if !strings.Contains(tf.path, DEVSHM) {
os.Remove(tf.path)
}
tf = nil
} | |
c11470 | value, err = prov.Call(ac.Provider, spec.Path)
if err != nil {
results <- Result{key, err}
wg.Done()
return
}
} else {
// If the spec isn't a variable, use its value as-is
value = spec.Path
}
envvar := formatForEnv(key, value, spec, &tempFactory)
results <- Result{envvar, ... | |
c11471 | := tempFactory.Push(value)
value = fname
}
return fmt.Sprintf("%s=%s", key, value)
} | |
c11472 | envFile = tempFactory.Push(joinEnv(env))
}
args[i] = strings.Replace(arg, ENV_FILE_MAGIC, envFile, -1)
}
}
return envFile
} | |
c11473 | s := strings.SplitN(sub, "=", 2)
key, val := s[0], s[1]
out[key] = val
}
return out
} | |
c11474 | {
return parse(content, env, subs)
} | |
c11475 | != nil {
return nil, err
}
return parse(string(data), env, subs)
} | |
c11476 | return parseRegular(ymlContent, subs)
}
return parseEnvironment(ymlContent, env, subs)
} | |
c11477 | return nil, err
}
secretsMap[i] = spec
}
// parse and merge optional 'common/default' section with secretsMap
for _, section := range COMMON_SECTIONS {
if _, ok := out[section]; ok {
return parseAndMergeCommon(out[section], secretsMap, subs)
}
}
return secretsMap, nil
} | |
c11478 | range out {
err := spec.applySubstitutions(subs)
if err != nil {
return nil, err
}
out[i] = spec
}
return out, nil
} | |
c11479 | if b == a {
return true
}
}
return false
} | |
c11480 | return err
}
defer l.Close()
return Serve(l, handler)
} | |
c11481 | &node{
pather: p,
}
nm[p] = n
}
return n
} | |
c11482 | neighborNode.open {
heap.Remove(nq, neighborNode.index)
}
neighborNode.open = false
neighborNode.closed = false
}
if !neighborNode.open && !neighborNode.closed {
neighborNode.cost = cost
neighborNode.open = true
neighborNode.rank = cost + neighbor.PathEstimatedCost(to)
neighborNo... | |
c11483 | append(neighbors, Pather(tube_element.to))
}
return neighbors
} | |
c11484 | range (t).out_to {
if Pather((tube_element.to)) == to {
return tube_element.Cost
}
}
return 10000000
} | |
c11485 | toT.Y - t.Y
if absY < 0 {
absY = -absY
}
r := float64(absX + absY)
return r
} | |
c11486 |
pT := p.(*Truck)
s = pT.label + " " + s
}
return s
} | |
c11487 | b[i] {
return ai < b[i]
}
}
return false
} | |
c11488 | binary.BigEndian.PutUint32(leaseBytes, uint32(d/time.Second))
return leaseBytes
} | |
c11489 | = append(b, v.To4()...)
}
return
} | |
c11490 | size := int(opts[1])
if len(opts) < 2+size {
break
}
options[OptionCode(opts[0])] = opts[2 : 2+size]
opts = opts[2+size:]
}
return options
} | |
c11491 | // Add Option Value
*p = append(*p, byte(End)) // Add on new End
} | |
c11492 | p.SetXId(xId)
if cIAddr != nil {
p.SetCIAddr(cIAddr)
}
p.SetBroadcast(broadcast)
p.AddOption(OptionDHCPMessageType, []byte{byte(mt)})
for _, o := range options {
p.AddOption(o.Code, o.Value)
}
p.PadToMinSize()
return p
} | |
c11493 | := ipv4.NewPacketConn(l)
if err := p.SetControlMessage(ipv4.FlagInterface, true); err != nil {
return nil, err
}
return &serveIfConn{ifIndex: iface.Index, conn: p}, nil
} | |
c11494 | tag,
hostname: hostname,
network: network,
raddr: raddr,
}
w.mu.Lock()
defer w.mu.Unlock()
err := w.connect()
if err != nil {
return nil, err
}
return w, err
} | |
c11495 |
for _, path := range logPaths {
conn, err := net.DialTimeout(network, path, localDeadline)
if err != nil {
continue
} else {
return &netConn{conn: conn, local: true}, nil
}
}
}
return nil, errors.New("Unix syslog delivery error")
} | |
c11496 | = b.writeAndRetry(syslog.LOG_WARNING, m)
case LOG_NOTICE:
_, err = b.writeAndRetry(syslog.LOG_NOTICE, m)
case LOG_INFO:
_, err = b.writeAndRetry(syslog.LOG_INFO, m)
case LOG_DEBUG:
_, err = b.writeAndRetry(syslog.LOG_DEBUG, m)
default:
err = fmt.Errorf("Unknown priority: %v", p)
}
return err
} | |
c11497 | nil
case "LOCAL0":
return syslog.LOG_LOCAL0, nil
case "LOCAL1":
return syslog.LOG_LOCAL1, nil
case "LOCAL2":
return syslog.LOG_LOCAL2, nil
case "LOCAL3":
return syslog.LOG_LOCAL3, nil
case "LOCAL4":
return syslog.LOG_LOCAL4, nil
case "LOCAL5":
return syslog.LOG_LOCAL5, nil
case "LOCAL6":
return sy... | |
c11498 |
return nil, err
}
out, err := s.ctx.Decrypt(s.handle, ciphertext)
if err != nil {
return nil, err
}
return out, nil
} | |
c11499 | C.int(p.params.ulIvLen))
iv := make([]byte, len(newIv))
copy(iv, newIv)
return iv
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.