_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 {
ret... | 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 ... | 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()
... | 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 po... | 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 "%":... | 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 b... | 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" //... | 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... | 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.... | 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 protoco... | 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... | 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(... | 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 ... | 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 ... | 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 = m... | 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
// conn... | 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 ... | 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 :=... | 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 ... | 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 "", f... | 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(stdE... | 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 ... | 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, ... | 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 sec... | 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
}
o... | 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).(*nod... | 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+s... | 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)) ... | 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)})... | 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.Ne... | 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 := &builtinWrit... | 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 {
conti... | 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:
... | 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":
r... | 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, ciphertex... | 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.