_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q11400 | Cast | train | func Cast(buf []byte) (Multihash, error) {
dm, err := Decode(buf)
if err != nil {
return Multihash{}, err
}
if !ValidCode(dm.Code) {
return Multihash{}, ErrUnknownCode
}
return Multihash(buf), nil
} | go | {
"resource": ""
} |
q11401 | Decode | train | func Decode(buf []byte) (*DecodedMultihash, error) {
if len(buf) < 2 {
return nil, ErrTooShort
}
var err error
var code, length uint64
code, buf, err = uvarint(buf)
if err != nil {
return nil, err
}
length, buf, err = uvarint(buf)
if err != nil {
return nil, err
}
if length > math.MaxInt32 {
return nil, errors.New("digest too long, supporting only <= 2^31-1")
}
dm := &DecodedMultihash{
Code: code,
Name: Codes[code],
Length: int(length),
Digest: buf,
}
if len(dm.Digest) != dm.Length {
return nil, ErrInconsistentLen{dm}
}
return dm, nil
} | go | {
"resource": ""
} |
q11402 | Sum | train | func Sum(data []byte, code uint64, length int) (Multihash, error) {
if !ValidCode(code) {
return nil, fmt.Errorf("invalid multihash code %d", code)
}
if length < 0 {
var ok bool
length, ok = DefaultLengths[code]
if !ok {
return nil, fmt.Errorf("no default length for code %d", code)
}
}
hashFunc, ok := funcTable[code]
if !ok {
return nil, ErrSumNotSupported
}
d, err := hashFunc(data, length)
if err != nil {
return nil, err
}
if length >= 0 {
d = d[:length]
}
return Encode(d, code)
} | go | {
"resource": ""
} |
q11403 | RegisterHashFunc | train | func RegisterHashFunc(code uint64, hashFunc HashFunc) error {
if !ValidCode(code) {
return fmt.Errorf("code %v not valid", code)
}
_, ok := funcTable[code]
if ok {
return fmt.Errorf("hash func for code %v already registered", code)
}
funcTable[code] = hashFunc
return nil
} | go | {
"resource": ""
} |
q11404 | init | train | func (s *scanner) init(buf string) {
s.buf = buf
s.pos = 0
s.start = 0
s.width = 0
s.accept = nil
} | go | {
"resource": ""
} |
q11405 | read | train | func (s *scanner) read() rune {
if s.pos >= len(s.buf) {
s.width = 0
return eof
}
r, w := utf8.DecodeRuneInString(s.buf[s.pos:])
s.width = w
s.pos += s.width
return r
} | go | {
"resource": ""
} |
q11406 | skip | train | func (s *scanner) skip() {
l := s.buf[:s.pos-1]
r := s.buf[s.pos:]
s.buf = l + r
} | go | {
"resource": ""
} |
q11407 | scan | train | func (s *scanner) scan() token {
s.start = s.pos
r := s.read()
switch {
case r == eof:
return tokenEOF
case s.scanLbrack(r):
return tokenLbrack
case s.scanRbrack(r):
return tokenRbrack
case s.scanIdent(r):
return tokenIdent
}
return tokenIllegal
} | go | {
"resource": ""
} |
q11408 | scanIdent | train | func (s *scanner) scanIdent(r rune) bool {
if s.mode&scanIdent == 0 {
return false
}
if s.scanEscaped(r) {
s.skip()
} else if !s.accept(r, s.pos-s.start) {
return false
}
loop:
for {
r := s.read()
switch {
case r == eof:
s.unread()
break loop
case s.scanLbrack(r):
s.unread()
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
} | go | {
"resource": ""
} |
q11409 | scanLbrack | train | func (s *scanner) scanLbrack(r rune) bool {
if s.mode&scanLbrack == 0 {
return false
}
if r == '$' {
if s.read() == '{' {
return true
}
s.unread()
}
return false
} | go | {
"resource": ""
} |
q11410 | scanRbrack | train | func (s *scanner) scanRbrack(r rune) bool {
if s.mode&scanRbrack == 0 {
return false
}
return r == '}'
} | go | {
"resource": ""
} |
q11411 | scanEscaped | train | func (s *scanner) scanEscaped(r rune) bool {
if s.mode&scanEscape == 0 {
return false
}
if r == '$' {
if s.peek() == '$' {
return true
}
}
if r != '\\' {
return false
}
switch s.peek() {
case '/', '\\':
return true
default:
return false
}
} | go | {
"resource": ""
} |
q11412 | Parse | train | func Parse(buf string) (*Tree, error) {
t := new(Tree)
t.scanner = new(scanner)
return t.Parse(buf)
} | go | {
"resource": ""
} |
q11413 | Parse | train | func (t *Tree) Parse(buf string) (tree *Tree, err error) {
t.scanner.init(buf)
t.Root, err = t.parseAny()
return t, err
} | go | {
"resource": ""
} |
q11414 | parseParam | train | func (t *Tree) parseParam(accept acceptFunc, mode byte) (Node, error) {
t.scanner.accept = accept
t.scanner.mode = mode | scanLbrack
switch t.scanner.scan() {
case tokenLbrack:
return t.parseFunc()
case tokenIdent:
return newTextNode(
t.scanner.string(),
), nil
default:
return nil, ErrBadSubstitution
}
} | go | {
"resource": ""
} |
q11415 | parseDefaultOrSubstr | train | func (t *Tree) parseDefaultOrSubstr(name string) (Node, error) {
t.scanner.read()
r := t.scanner.peek()
t.scanner.unread()
switch r {
case '=', '-', '?', '+':
return t.parseDefaultFunc(name)
default:
return t.parseSubstrFunc(name)
}
} | go | {
"resource": ""
} |
q11416 | consumeRbrack | train | func (t *Tree) consumeRbrack() error {
t.scanner.mode = scanRbrack
if t.scanner.scan() != tokenRbrack {
return ErrBadSubstitution
}
return nil
} | go | {
"resource": ""
} |
q11417 | toLen | train | func toLen(s string, args ...string) string {
return strconv.Itoa(len(s))
} | go | {
"resource": ""
} |
q11418 | toLowerFirst | train | func toLowerFirst(s string, args ...string) string {
if s == "" {
return s
}
r, n := utf8.DecodeRuneInString(s)
return string(unicode.ToLower(r)) + s[n:]
} | go | {
"resource": ""
} |
q11419 | toUpperFirst | train | func toUpperFirst(s string, args ...string) string {
if s == "" {
return s
}
r, n := utf8.DecodeRuneInString(s)
return string(unicode.ToUpper(r)) + s[n:]
} | go | {
"resource": ""
} |
q11420 | toDefault | train | func toDefault(s string, args ...string) string {
if len(s) == 0 && len(args) == 1 {
s = args[0]
}
return s
} | go | {
"resource": ""
} |
q11421 | toSubstr | train | func toSubstr(s string, args ...string) string {
if len(args) == 0 {
return s // should never happen
}
pos, err := strconv.Atoi(args[0])
if err != nil {
// bash returns the string if the position
// cannot be parsed.
return s
}
if len(args) == 1 {
if pos < len(s) {
return s[pos:]
}
// if the position exceeds the length of the
// string an empty string is returned
return ""
}
length, err := strconv.Atoi(args[1])
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]
} | go | {
"resource": ""
} |
q11422 | replaceAll | train | func replaceAll(s string, args ...string) string {
switch len(args) {
case 0:
return s
case 1:
return strings.Replace(s, args[0], "", -1)
default:
return strings.Replace(s, args[0], args[1], -1)
}
} | go | {
"resource": ""
} |
q11423 | replaceFirst | train | func replaceFirst(s string, args ...string) string {
switch len(args) {
case 0:
return s
case 1:
return strings.Replace(s, args[0], "", 1)
default:
return strings.Replace(s, args[0], args[1], 1)
}
} | go | {
"resource": ""
} |
q11424 | replacePrefix | train | func replacePrefix(s string, args ...string) string {
if len(args) != 2 {
return s
}
if strings.HasPrefix(s, args[0]) {
return strings.Replace(s, args[0], args[1], 1)
}
return s
} | go | {
"resource": ""
} |
q11425 | replaceSuffix | train | func replaceSuffix(s string, args ...string) string {
if len(args) != 2 {
return s
}
if strings.HasSuffix(s, args[0]) {
s = strings.TrimSuffix(s, args[0])
s = s + args[1]
}
return s
} | go | {
"resource": ""
} |
q11426 | Parse | train | func Parse(s string) (t *Template, err error) {
t = new(Template)
t.tree, err = parse.Parse(s)
if err != nil {
return nil, err
}
return t, nil
} | go | {
"resource": ""
} |
q11427 | Execute | train | func (t *Template) Execute(mapping func(string) string) (str string, err error) {
b := new(bytes.Buffer)
s := new(state)
s.node = t.tree.Root
s.mapper = mapping
s.writer = b
err = t.eval(s)
if err != nil {
return
}
return b.String(), nil
} | go | {
"resource": ""
} |
q11428 | lookupFunc | train | func lookupFunc(name string, args int) substituteFunc {
switch name {
case ",":
return toLowerFirst
case ",,":
return toLower
case "^":
return toUpperFirst
case "^^":
return toUpper
case "#":
if args == 0 {
return toLen
}
return trimShortestPrefix
case "##":
return trimLongestPrefix
case "%":
return trimShortestSuffix
case "%%":
return trimLongestSuffix
case ":":
return toSubstr
case "/#":
return replacePrefix
case "/%":
return replaceSuffix
case "/":
return replaceFirst
case "//":
return replaceAll
case "=", ":=", ":-":
return toDefault
case ":?", ":+", "-", "+":
return toDefault
default:
return toDefault
}
} | go | {
"resource": ""
} |
q11429 | Backoff | train | func (db *DialBackoff) Backoff(p peer.ID) (backoff bool) {
db.lock.Lock()
defer db.lock.Unlock()
db.init()
bp, found := db.entries[p]
if found && time.Now().Before(bp.until) {
return true
}
return false
} | go | {
"resource": ""
} |
q11430 | Clear | train | func (db *DialBackoff) Clear(p peer.ID) {
db.lock.Lock()
defer db.lock.Unlock()
db.init()
delete(db.entries, p)
} | go | {
"resource": ""
} |
q11431 | doDial | train | func (s *Swarm) doDial(ctx context.Context, p peer.ID) (*Conn, error) {
// Short circuit.
// By the time we take the dial lock, we may already *have* a connection
// to the peer.
c := s.bestConnToPeer(p)
if c != nil {
return c, nil
}
logdial := lgbl.Dial("swarm", s.LocalPeer(), p, nil, nil)
// ok, we have been charged to dial! let's do it.
// if it succeeds, dial will add the conn to the swarm itself.
defer log.EventBegin(ctx, "swarmDialAttemptStart", logdial).Done()
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 have a connection: %s", err)
return conn, nil
}
if err != context.Canceled {
log.Event(ctx, "swarmDialBackoffAdd", logdial)
s.backf.AddBackoff(p) // let others know to backoff
}
// ok, we failed.
return nil, err
}
return conn, nil
} | go | {
"resource": ""
} |
q11432 | dial | train | func (s *Swarm) dial(ctx context.Context, p peer.ID) (*Conn, error) {
var logdial = lgbl.Dial("swarm", s.LocalPeer(), p, nil, nil)
if p == s.local {
log.Event(ctx, "swarmDialDoDialSelf", logdial)
return nil, ErrDialToSelf
}
defer log.EventBegin(ctx, "swarmDialDo", logdial).Done()
logdial["dial"] = "failure" // start off with failure. set to "success" at the end.
sk := s.peers.PrivKey(s.local)
logdial["encrypted"] = sk != nil // log whether this will be an encrypted dial or not.
if sk == nil {
// fine for sk to be nil, just log.
log.Debug("Dial not given PrivateKey, so WILL NOT SECURE conn.")
}
//////
/*
This slice-to-chan code is temporary, the peerstore can currently provide
a channel as an interface for receiving addresses, but more thought
needs to be put into the execution. For now, this allows us to use
the improved rate limiter, while maintaining the outward behaviour
that we previously had (halting a dial when we run out of addrs)
*/
peerAddrs := s.peers.Addrs(p)
if len(peerAddrs) == 0 {
return nil, &DialError{Peer: p, Cause: ErrNoAddresses}
}
goodAddrs := s.filterKnownUndialables(peerAddrs)
if len(goodAddrs) == 0 {
return nil, &DialError{Peer: p, Cause: ErrNoGoodAddresses}
}
goodAddrsChan := make(chan ma.Multiaddr, len(goodAddrs))
for _, a := range goodAddrs {
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 rely on behing able to check `err == context.Canceled`
//
// Removing this will BREAK backoff (causing us to
// backoff when canceling dials).
return nil, context.Canceled
}
return nil, dialErr
}
logdial["conn"] = logging.Metadata{
"localAddr": connC.LocalMultiaddr(),
"remoteAddr": connC.RemoteMultiaddr(),
}
swarmC, err := s.addConn(connC, inet.DirOutbound)
if err != nil {
logdial["error"] = err.Error()
connC.Close() // close the connection. didn't work out :(
return nil, &DialError{Peer: p, Cause: err}
}
logdial["dial"] = "success"
return swarmC, nil
} | go | {
"resource": ""
} |
q11433 | limitedDial | train | func (s *Swarm) limitedDial(ctx context.Context, p peer.ID, a ma.Multiaddr, resp chan dialResult) {
s.limiter.AddDialJob(&dialJob{
addr: a,
peer: p,
resp: resp,
ctx: ctx,
})
} | go | {
"resource": ""
} |
q11434 | freeFDToken | train | func (dl *dialLimiter) freeFDToken() {
log.Debugf("[limiter] freeing FD token; waiting: %d; consuming: %d", len(dl.waitingOnFd), dl.fdConsuming)
dl.fdConsuming--
for len(dl.waitingOnFd) > 0 {
next := dl.waitingOnFd[0]
dl.waitingOnFd[0] = nil // clear out memory
dl.waitingOnFd = dl.waitingOnFd[1:]
if len(dl.waitingOnFd) == 0 {
// clear out memory.
dl.waitingOnFd = nil
}
// Skip over canceled 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
}
} | go | {
"resource": ""
} |
q11435 | AddDialJob | train | func (dl *dialLimiter) AddDialJob(dj *dialJob) {
dl.lk.Lock()
defer dl.lk.Unlock()
log.Debugf("[limiter] adding a dial job through limiter: %v", dj.addr)
dl.addCheckPeerLimit(dj)
} | go | {
"resource": ""
} |
q11436 | executeDial | train | func (dl *dialLimiter) executeDial(j *dialJob) {
defer dl.finishedDial(j)
if j.cancelled() {
return
}
dctx, cancel := context.WithTimeout(j.ctx, j.dialTimeout())
defer cancel()
con, err := dl.dialFunc(dctx, j.peer, j.addr)
select {
case j.resp <- dialResult{Conn: con, Addr: j.addr, Err: err}:
case <-j.ctx.Done():
if err == nil {
con.Close()
}
}
} | go | {
"resource": ""
} |
q11437 | TransportForDialing | train | func (s *Swarm) TransportForDialing(a ma.Multiaddr) transport.Transport {
protocols := a.Protocols()
if len(protocols) == 0 {
return nil
}
s.transports.RLock()
defer s.transports.RUnlock()
if len(s.transports.m) == 0 {
log.Error("you have no transports configured")
return nil
}
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]
} | go | {
"resource": ""
} |
q11438 | AddTransport | train | func (s *Swarm) AddTransport(t transport.Transport) error {
protocols := t.Protocols()
if len(protocols) == 0 {
return fmt.Errorf("useless transport handles no protocols: %T", t)
}
s.transports.Lock()
defer s.transports.Unlock()
var registered []string
for _, p := range protocols {
if _, ok := s.transports.m[p]; ok {
proto := ma.ProtocolWithCode(p)
name := proto.Name
if name == "" {
name = 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
} | go | {
"resource": ""
} |
q11439 | AddListenAddr | train | func (s *Swarm) AddListenAddr(a ma.Multiaddr) error {
tpt := s.TransportForListening(a)
if tpt == nil {
return ErrNoTransport
}
list, err := tpt.Listen(a)
if err != nil {
return err
}
s.listeners.Lock()
if s.listeners.m == nil {
s.listeners.Unlock()
list.Close()
return ErrSwarmClosed
}
s.refs.Add(1)
s.listeners.m[list] = struct{}{}
s.listeners.Unlock()
maddr := list.Multiaddr()
// signal to our notifiees on successful conn.
s.notifyAll(func(n inet.Notifiee) {
n.Listen(s, maddr)
})
go func() {
defer func() {
list.Close()
s.listeners.Lock()
delete(s.listeners.m, list)
s.listeners.Unlock()
s.refs.Done()
}()
for {
c, err := list.Accept()
if err != nil {
if s.ctx.Err() == nil {
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.
log.Warningf("add conn failed: ", err)
return
}
}()
}
}()
return nil
} | go | {
"resource": ""
} |
q11440 | NewDialSync | train | func NewDialSync(dfn DialFunc) *DialSync {
return &DialSync{
dials: make(map[peer.ID]*activeDial),
dialFunc: dfn,
}
} | go | {
"resource": ""
} |
q11441 | DialLock | train | func (ds *DialSync) DialLock(ctx context.Context, p peer.ID) (*Conn, error) {
return ds.getActiveDial(p).wait(ctx)
} | go | {
"resource": ""
} |
q11442 | CancelDial | train | func (ds *DialSync) CancelDial(p peer.ID) {
ds.dialsLk.Lock()
defer ds.dialsLk.Unlock()
if ad, ok := ds.dials[p]; ok {
ad.cancel()
}
} | go | {
"resource": ""
} |
q11443 | start | train | func (c *Conn) start() {
go func() {
defer c.swarm.refs.Done()
defer c.Close()
for {
ts, err := c.conn.AcceptStream()
if err != nil {
return
}
c.swarm.refs.Add(1)
go func() {
s, err := c.addStream(ts, inet.DirInbound)
// Don't defer this. We don't want to block
// swarm shutdown on the connection handler.
c.swarm.refs.Done()
// 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)
}
}()
}
}()
} | go | {
"resource": ""
} |
q11444 | NewStream | train | func (c *Conn) NewStream() (inet.Stream, error) {
ts, err := c.conn.OpenStream()
if err != nil {
return nil, err
}
return c.addStream(ts, inet.DirOutbound)
} | go | {
"resource": ""
} |
q11445 | GetStreams | train | func (c *Conn) GetStreams() []inet.Stream {
c.streams.Lock()
defer c.streams.Unlock()
streams := make([]inet.Stream, 0, len(c.streams.m))
for s := range c.streams.m {
streams = append(streams, s)
}
return streams
} | go | {
"resource": ""
} |
q11446 | Read | train | func (s *Stream) Read(p []byte) (int, error) {
n, err := s.stream.Read(p)
// TODO: push this down to a lower level for better accuracy.
if s.conn.swarm.bwc != nil {
s.conn.swarm.bwc.LogRecvMessage(int64(n))
s.conn.swarm.bwc.LogRecvMessageStream(int64(n), s.Protocol(), s.Conn().RemotePeer())
}
// If we observe an EOF, this stream is now closed for reading.
// If we're already closed for writing, this stream is now fully closed.
if err == io.EOF {
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
} | go | {
"resource": ""
} |
q11447 | Write | train | func (s *Stream) Write(p []byte) (int, error) {
n, err := s.stream.Write(p)
// TODO: push this down to a lower level for better accuracy.
if s.conn.swarm.bwc != nil {
s.conn.swarm.bwc.LogSentMessage(int64(n))
s.conn.swarm.bwc.LogSentMessageStream(int64(n), s.Protocol(), s.Conn().RemotePeer())
}
return n, err
} | go | {
"resource": ""
} |
q11448 | Close | train | func (s *Stream) Close() error {
err := s.stream.Close()
s.state.Lock()
switch s.state.v {
case streamCloseRead:
s.state.v = streamCloseBoth
s.remove()
case streamOpen:
s.state.v = streamCloseWrite
}
s.state.Unlock()
return err
} | go | {
"resource": ""
} |
q11449 | Reset | train | func (s *Stream) Reset() error {
err := s.stream.Reset()
s.state.Lock()
switch s.state.v {
case streamOpen, streamCloseRead, streamCloseWrite:
s.state.v = streamReset
s.remove()
}
s.state.Unlock()
return err
} | go | {
"resource": ""
} |
q11450 | NewSwarm | train | func NewSwarm(ctx context.Context, local peer.ID, peers pstore.Peerstore, bwc metrics.Reporter) *Swarm {
s := &Swarm{
local: local,
peers: peers,
bwc: bwc,
Filters: filter.NewFilters(),
}
s.conns.m = make(map[peer.ID][]*Conn)
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.OnClosingContext(s.proc)
return s
} | go | {
"resource": ""
} |
q11451 | AddAddrFilter | train | func (s *Swarm) AddAddrFilter(f string) error {
m, err := mafilter.NewMask(f)
if err != nil {
return err
}
s.Filters.AddDialFilter(m)
return nil
} | go | {
"resource": ""
} |
q11452 | ConnHandler | train | func (s *Swarm) ConnHandler() inet.ConnHandler {
handler, _ := s.connh.Load().(inet.ConnHandler)
return handler
} | go | {
"resource": ""
} |
q11453 | SetStreamHandler | train | func (s *Swarm) SetStreamHandler(handler inet.StreamHandler) {
s.streamh.Store(handler)
} | go | {
"resource": ""
} |
q11454 | StreamHandler | train | func (s *Swarm) StreamHandler() inet.StreamHandler {
handler, _ := s.streamh.Load().(inet.StreamHandler)
return handler
} | go | {
"resource": ""
} |
q11455 | NewStream | train | func (s *Swarm) NewStream(ctx context.Context, p peer.ID) (inet.Stream, error) {
log.Debugf("[%s] opening stream to peer [%s]", s.local, p)
// Algorithm:
// 1. Find the best connection, otherwise, dial.
// 2. Try opening a stream.
// 3. If the underlying connection is, in fact, closed, close the outer
// connection and try again. We do this in case we have a closed
// connection but don't notice it until we actually try to open a
// stream.
//
// Note: We only dial once.
//
// TODO: Try all connections even if we get an error opening a stream on
// a non-closed connection.
dials := 0
for {
c := s.bestConnToPeer(p)
if c == nil {
if nodial, _ := inet.GetNoDial(ctx); nodial {
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
}
return nil, err
}
return s, nil
}
} | go | {
"resource": ""
} |
q11456 | ConnsToPeer | train | func (s *Swarm) ConnsToPeer(p peer.ID) []inet.Conn {
// TODO: Consider sorting the connection list best to worst. Currently,
// it's sorted oldest to newest.
s.conns.RLock()
defer s.conns.RUnlock()
conns := s.conns.m[p]
output := make([]inet.Conn, len(conns))
for i, c := range conns {
output[i] = c
}
return output
} | go | {
"resource": ""
} |
q11457 | bestConnToPeer | train | func (s *Swarm) bestConnToPeer(p peer.ID) *Conn {
// Selects the best connection we have to the peer.
// TODO: Prefer some transports over others. Currently, we just select
// the newest non-closed connection with the most streams.
s.conns.RLock()
defer s.conns.RUnlock()
var best *Conn
bestLen := 0
for _, c := range s.conns.m[p] {
if c.conn.IsClosed() {
// We *will* garbage collect this soon anyways.
continue
}
c.streams.Lock()
cLen := len(c.streams.m)
c.streams.Unlock()
if cLen >= bestLen {
best = c
bestLen = cLen
}
}
return best
} | go | {
"resource": ""
} |
q11458 | Conns | train | func (s *Swarm) Conns() []inet.Conn {
s.conns.RLock()
defer s.conns.RUnlock()
conns := make([]inet.Conn, 0, len(s.conns.m))
for _, cs := range s.conns.m {
for _, c := range cs {
conns = append(conns, c)
}
}
return conns
} | go | {
"resource": ""
} |
q11459 | ClosePeer | train | func (s *Swarm) ClosePeer(p peer.ID) error {
conns := s.ConnsToPeer(p)
switch len(conns) {
case 0:
return nil
case 1:
return conns[0].Close()
default:
errCh := make(chan error)
for _, c := range conns {
go func(c inet.Conn) {
errCh <- c.Close()
}(c)
}
var errs []string
for _ = range conns {
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
}
} | go | {
"resource": ""
} |
q11460 | Peers | train | func (s *Swarm) Peers() []peer.ID {
s.conns.RLock()
defer s.conns.RUnlock()
peers := make([]peer.ID, 0, len(s.conns.m))
for p := range s.conns.m {
peers = append(peers, p)
}
return peers
} | go | {
"resource": ""
} |
q11461 | notifyAll | train | func (s *Swarm) notifyAll(notify func(inet.Notifiee)) {
var wg sync.WaitGroup
s.notifs.RLock()
wg.Add(len(s.notifs.m))
for f := range s.notifs.m {
go func(f inet.Notifiee) {
defer wg.Done()
notify(f)
}(f)
}
wg.Wait()
s.notifs.RUnlock()
} | go | {
"resource": ""
} |
q11462 | ListenAddresses | train | func (s *Swarm) ListenAddresses() []ma.Multiaddr {
s.listeners.RLock()
defer s.listeners.RUnlock()
addrs := make([]ma.Multiaddr, 0, len(s.listeners.m))
for l := range s.listeners.m {
addrs = append(addrs, l.Multiaddr())
}
return addrs
} | go | {
"resource": ""
} |
q11463 | NewWithServer | train | func NewWithServer(s *http.Server) *GracefulServer {
return &GracefulServer{
Server: s,
shutdown: make(chan bool),
shutdownFinished: make(chan bool, 1),
wg: new(sync.WaitGroup),
routinesCount: 0,
connections: make(map[net.Conn]bool),
}
} | go | {
"resource": ""
} |
q11464 | RoutinesCount | train | func (s *GracefulServer) RoutinesCount() int {
s.lcsmu.RLock()
defer s.lcsmu.RUnlock()
return s.routinesCount
} | go | {
"resource": ""
} |
q11465 | runSubcommand | train | func runSubcommand(command []string, env []string) error {
binary, lookupErr := exec.LookPath(command[0])
if lookupErr != nil {
return lookupErr
}
return syscall.Exec(binary, command, env)
} | go | {
"resource": ""
} |
q11466 | Resolve | train | func Resolve(providerArg string) (string, error) {
provider := providerArg
if provider == "" {
provider = os.Getenv("SUMMON_PROVIDER")
}
if provider == "" {
providers, _ := ioutil.ReadDir(DefaultPath)
if len(providers) == 1 {
provider = providers[0].Name()
} else if len(providers) > 1 {
return "", fmt.Errorf("More than one provider found in %s, please specify one\n", DefaultPath)
}
}
provider = expandPath(provider)
if provider == "" {
return "", fmt.Errorf("Could not resolve a provider!")
}
_, err := os.Stat(provider)
if err != nil {
return "", err
}
return provider, nil
} | go | {
"resource": ""
} |
q11467 | Call | train | func Call(provider, specPath string) (string, error) {
var (
stdOut bytes.Buffer
stdErr bytes.Buffer
)
cmd := exec.Command(provider, specPath)
cmd.Stdout = &stdOut
cmd.Stderr = &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
} | go | {
"resource": ""
} |
q11468 | Push | train | func (tf *TempFactory) Push(value string) string {
f, _ := ioutil.TempFile(tf.path, ".summon")
defer f.Close()
f.Write([]byte(value))
name := f.Name()
tf.files = append(tf.files, name)
return name
} | go | {
"resource": ""
} |
q11469 | Cleanup | train | func (tf *TempFactory) Cleanup() {
for _, file := range tf.files {
os.Remove(file)
}
// Also remove the tempdir if it's not DEVSHM
if !strings.Contains(tf.path, DEVSHM) {
os.Remove(tf.path)
}
tf = nil
} | go | {
"resource": ""
} |
q11470 | runAction | train | func runAction(ac *ActionConfig) error {
var (
secrets secretsyml.SecretsMap
err error
)
switch ac.YamlInline {
case "":
secrets, err = secretsyml.ParseFromFile(ac.Filepath, ac.Environment, ac.Subs)
default:
secrets, err = secretsyml.ParseFromString(ac.YamlInline, ac.Environment, ac.Subs)
}
if err != nil {
return err
}
var env []string
tempFactory := NewTempFactory("")
defer tempFactory.Cleanup()
type Result struct {
string
error
}
// Run provider calls concurrently
results := make(chan Result, len(secrets))
var wg sync.WaitGroup
for key, spec := range secrets {
wg.Add(1)
go func(key string, spec secretsyml.SecretSpec) {
var value string
if spec.IsVar() {
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, nil}
wg.Done()
}(key, spec)
}
wg.Wait()
close(results)
EnvLoop:
for envvar := range results {
if envvar.error == nil {
env = append(env, envvar.string)
} else {
if ac.IgnoreAll {
continue EnvLoop
}
for i := range ac.Ignores {
if ac.Ignores[i] == envvar.string {
continue EnvLoop
}
}
return fmt.Errorf("Error fetching variable %v: %v", envvar.string, envvar.error.Error())
}
}
// Append environment variable if one is specified
if ac.Environment != "" {
env = append(env, fmt.Sprintf("%s=%s", SUMMON_ENV_KEY_NAME, ac.Environment))
}
setupEnvFile(ac.Args, env, &tempFactory)
return runSubcommand(ac.Args, append(os.Environ(), env...))
} | go | {
"resource": ""
} |
q11471 | formatForEnv | train | func formatForEnv(key string, value string, spec secretsyml.SecretSpec, tempFactory *TempFactory) string {
if spec.IsFile() {
fname := tempFactory.Push(value)
value = fname
}
return fmt.Sprintf("%s=%s", key, value)
} | go | {
"resource": ""
} |
q11472 | setupEnvFile | train | func setupEnvFile(args []string, env []string, tempFactory *TempFactory) string {
var envFile = ""
for i, arg := range args {
idx := strings.Index(arg, ENV_FILE_MAGIC)
if idx >= 0 {
if envFile == "" {
envFile = tempFactory.Push(joinEnv(env))
}
args[i] = strings.Replace(arg, ENV_FILE_MAGIC, envFile, -1)
}
}
return envFile
} | go | {
"resource": ""
} |
q11473 | convertSubsToMap | train | func convertSubsToMap(subs []string) map[string]string {
out := make(map[string]string)
for _, sub := range subs {
s := strings.SplitN(sub, "=", 2)
key, val := s[0], s[1]
out[key] = val
}
return out
} | go | {
"resource": ""
} |
q11474 | ParseFromString | train | func ParseFromString(content, env string, subs map[string]string) (SecretsMap, error) {
return parse(content, env, subs)
} | go | {
"resource": ""
} |
q11475 | ParseFromFile | train | func ParseFromFile(filepath, env string, subs map[string]string) (SecretsMap, error) {
data, err := ioutil.ReadFile(filepath)
if err != nil {
return nil, err
}
return parse(string(data), env, subs)
} | go | {
"resource": ""
} |
q11476 | parse | train | func parse(ymlContent, env string, subs map[string]string) (SecretsMap, error) {
if env == "" {
return parseRegular(ymlContent, subs)
}
return parseEnvironment(ymlContent, env, subs)
} | go | {
"resource": ""
} |
q11477 | parseEnvironment | train | func parseEnvironment(ymlContent, env string, subs map[string]string) (SecretsMap, error) {
out := make(map[string]map[string]SecretSpec)
if err := yaml.Unmarshal([]byte(ymlContent), &out); err != nil {
return nil, err
}
if _, ok := out[env]; !ok {
return nil, fmt.Errorf("No such environment '%v' found in secrets file", env)
}
secretsMap := make(SecretsMap)
for i, spec := range out[env] {
err := spec.applySubstitutions(subs)
if err != nil {
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
} | go | {
"resource": ""
} |
q11478 | parseRegular | train | func parseRegular(ymlContent string, subs map[string]string) (SecretsMap, error) {
out := make(map[string]SecretSpec)
if err := yaml.Unmarshal([]byte(ymlContent), &out); err != nil {
return nil, err
}
for i, spec := range out {
err := spec.applySubstitutions(subs)
if err != nil {
return nil, err
}
out[i] = spec
}
return out, nil
} | go | {
"resource": ""
} |
q11479 | tagInSlice | train | func tagInSlice(a YamlTag, list []YamlTag) bool {
for _, b := range list {
if b == a {
return true
}
}
return false
} | go | {
"resource": ""
} |
q11480 | ListenAndServe | train | func ListenAndServe(handler Handler) error {
l, err := net.ListenPacket("udp4", ":67")
if err != nil {
return err
}
defer l.Close()
return Serve(l, handler)
} | go | {
"resource": ""
} |
q11481 | get | train | func (nm nodeMap) get(p Pather) *node {
n, ok := nm[p]
if !ok {
n = &node{
pather: p,
}
nm[p] = n
}
return n
} | go | {
"resource": ""
} |
q11482 | Path | train | func Path(from, to Pather) (path []Pather, distance float64, found bool) {
nm := nodeMap{}
nq := &priorityQueue{}
heap.Init(nq)
fromNode := nm.get(from)
fromNode.open = true
heap.Push(nq, fromNode)
for {
if nq.Len() == 0 {
// There's no path, return found false.
return
}
current := heap.Pop(nq).(*node)
current.open = false
current.closed = true
if current == nm.get(to) {
// Found a path to the goal.
p := []Pather{}
curr := current
for curr != nil {
p = append(p, curr.pather)
curr = curr.parent
}
return p, current.cost, true
}
for _, neighbor := range current.pather.PathNeighbors() {
cost := current.cost + current.pather.PathNeighborCost(neighbor)
neighborNode := nm.get(neighbor)
if cost < neighborNode.cost {
if 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)
neighborNode.parent = current
heap.Push(nq, neighborNode)
}
}
}
} | go | {
"resource": ""
} |
q11483 | PathNeighbors | train | func (t *Truck) PathNeighbors() []Pather {
neighbors := []Pather{}
for _, tube_element := range t.out_to {
neighbors = append(neighbors, Pather(tube_element.to))
}
return neighbors
} | go | {
"resource": ""
} |
q11484 | PathNeighborCost | train | func (t *Truck) PathNeighborCost(to Pather) float64 {
for _, tube_element := range (t).out_to {
if Pather((tube_element.to)) == to {
return tube_element.Cost
}
}
return 10000000
} | go | {
"resource": ""
} |
q11485 | PathEstimatedCost | train | func (t *Truck) PathEstimatedCost(to Pather) float64 {
toT := to.(*Truck)
absX := toT.X - t.X
if absX < 0 {
absX = -absX
}
absY := toT.Y - t.Y
if absY < 0 {
absY = -absY
}
r := float64(absX + absY)
return r
} | go | {
"resource": ""
} |
q11486 | RenderPath | train | func (w Goreland) RenderPath(path []Pather) string {
s := ""
for _, p := range path {
pT := p.(*Truck)
s = pT.label + " " + s
}
return s
} | go | {
"resource": ""
} |
q11487 | IPLess | train | func IPLess(a, b net.IP) bool {
b = b.To4()
for i, ai := range a.To4() {
if ai != b[i] {
return ai < b[i]
}
}
return false
} | go | {
"resource": ""
} |
q11488 | OptionsLeaseTime | train | func OptionsLeaseTime(d time.Duration) []byte {
leaseBytes := make([]byte, 4)
binary.BigEndian.PutUint32(leaseBytes, uint32(d/time.Second))
return leaseBytes
} | go | {
"resource": ""
} |
q11489 | JoinIPs | train | func JoinIPs(ips []net.IP) (b []byte) {
for _, v := range ips {
b = append(b, v.To4()...)
}
return
} | go | {
"resource": ""
} |
q11490 | ParseOptions | train | func (p Packet) ParseOptions() Options {
opts := p.Options()
options := make(Options, 10)
for len(opts) >= 2 && OptionCode(opts[0]) != End {
if OptionCode(opts[0]) == Pad {
opts = opts[1:]
continue
}
size := int(opts[1])
if len(opts) < 2+size {
break
}
options[OptionCode(opts[0])] = opts[2 : 2+size]
opts = opts[2+size:]
}
return options
} | go | {
"resource": ""
} |
q11491 | AddOption | train | func (p *Packet) AddOption(o OptionCode, value []byte) {
*p = append((*p)[:len(*p)-1], []byte{byte(o), byte(len(value))}...) // Strip off End, Add OptionCode and Length
*p = append(*p, value...) // Add Option Value
*p = append(*p, byte(End)) // Add on new End
} | go | {
"resource": ""
} |
q11492 | RequestPacket | train | func RequestPacket(mt MessageType, chAddr net.HardwareAddr, cIAddr net.IP, xId []byte, broadcast bool, options []Option) Packet {
p := NewPacket(BootRequest)
p.SetCHAddr(chAddr)
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
} | go | {
"resource": ""
} |
q11493 | NewUDP4FilterListener | train | func NewUDP4FilterListener(interfaceName, laddr string) (c *serveIfConn, e error) {
iface, err := net.InterfaceByName(interfaceName)
if err != nil {
return nil, err
}
l, err := net.ListenPacket("udp4", laddr)
if err != nil {
return nil, err
}
defer func() {
if e != nil {
l.Close()
}
}()
p := ipv4.NewPacketConn(l)
if err := p.SetControlMessage(ipv4.FlagInterface, true); err != nil {
return nil, err
}
return &serveIfConn{ifIndex: iface.Index, conn: p}, nil
} | go | {
"resource": ""
} |
q11494 | dialBuiltin | train | func dialBuiltin(network, raddr string, priority syslog.Priority, tag string) (*builtinWriter, error) {
if priority < 0 || priority > syslog.LOG_LOCAL7|syslog.LOG_DEBUG {
return nil, errors.New("log/syslog: invalid priority")
}
if tag == "" {
tag = os.Args[0]
}
hostname, _ := os.Hostname()
w := &builtinWriter{
priority: priority,
tag: 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
} | go | {
"resource": ""
} |
q11495 | unixSyslog | train | func unixSyslog() (conn serverConn, err error) {
logTypes := []string{"unixgram", "unix"}
logPaths := []string{"/dev/log", "/var/run/syslog", "/var/run/log"}
for _, network := range logTypes {
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")
} | go | {
"resource": ""
} |
q11496 | WriteLevel | train | func (b *builtinLogger) WriteLevel(p Priority, buf []byte) error {
var err error
m := string(buf)
switch p {
case LOG_EMERG:
_, err = b.writeAndRetry(syslog.LOG_EMERG, m)
case LOG_ALERT:
_, err = b.writeAndRetry(syslog.LOG_ALERT, m)
case LOG_CRIT:
_, err = b.writeAndRetry(syslog.LOG_CRIT, m)
case LOG_ERR:
_, err = b.writeAndRetry(syslog.LOG_ERR, m)
case LOG_WARNING:
_, err = 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
} | go | {
"resource": ""
} |
q11497 | facilityPriority | train | func facilityPriority(facility string) (syslog.Priority, error) {
facility = strings.ToUpper(facility)
switch facility {
case "KERN":
return syslog.LOG_KERN, nil
case "USER":
return syslog.LOG_USER, nil
case "MAIL":
return syslog.LOG_MAIL, nil
case "DAEMON":
return syslog.LOG_DAEMON, nil
case "AUTH":
return syslog.LOG_AUTH, nil
case "SYSLOG":
return syslog.LOG_SYSLOG, nil
case "LPR":
return syslog.LOG_LPR, nil
case "NEWS":
return syslog.LOG_NEWS, nil
case "UUCP":
return syslog.LOG_UUCP, nil
case "CRON":
return syslog.LOG_CRON, nil
case "AUTHPRIV":
return syslog.LOG_AUTHPRIV, nil
case "FTP":
return syslog.LOG_FTP, 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 syslog.LOG_LOCAL6, nil
case "LOCAL7":
return syslog.LOG_LOCAL7, nil
default:
return 0, fmt.Errorf("invalid syslog facility: %s", facility)
}
} | go | {
"resource": ""
} |
q11498 | Decrypt | train | func (secret SecretKey) Decrypt(mechanism pkcs11.Mechanism, ciphertext []byte) ([]byte, error) {
s := secret.session
s.Lock()
defer s.Unlock()
err := s.ctx.DecryptInit(s.handle, []*pkcs11.Mechanism{&mechanism}, secret.objectHandle)
if err != nil {
return nil, err
}
out, err := s.ctx.Decrypt(s.handle, ciphertext)
if err != nil {
return nil, err
}
return out, nil
} | go | {
"resource": ""
} |
q11499 | IV | train | func (p *GCMParams) IV() []byte {
if p == nil || p.params == nil {
return nil
}
newIv := C.GoBytes(unsafe.Pointer(p.params.pIv), C.int(p.params.ulIvLen))
iv := make([]byte, len(newIv))
copy(iv, newIv)
return iv
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.