id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c25200 | {
sum += *datapoint.Sum
}
return int(sum)
} | |
c25201 |
return fmt.Sprintf("%s hook: %s", e.Hook, e.Output)
} | |
c25202 | return p.run("build", fn.Hooks.Build, fn)
} | |
c25203 | p.run("deploy", fn.Hooks.Deploy, fn)
} | |
c25204 | runtime.GOOS == "windows" {
cmd = exec.Command("cmd", "/c", command)
} else {
cmd = exec.Command("sh", "-c", command)
}
cmd.Env = os.Environ()
cmd.Dir = fn.Path
b, err := cmd.CombinedOutput()
if err != nil {
return &HookError{
Hook: hook,
Command: command,
Output: string(b),
}
}
return n... | |
c25205 | range h {
if keepFields[k] {
continue
}
h.Del(k)
}
} | |
c25206 |
if err := json.Unmarshal(b, &v); err != nil {
return errors.Wrap(err, "unmarshaling")
}
return nil
} | |
c25207 | name.CamelCase(fmt.Sprintf(s, v...), true)
} | |
c25208 | colors.Gray("|")
b.EndDelimiter = colors.Gray("|")
b.Filled = colors.Purple("█")
b.Empty = colors.Gray(" ")
return b
} | |
c25209 | "\n %s %s\n\n", colors.Red("Error:"), err)
os.Exit(1)
} | |
c25210 | s[0] == '{' && s[len(s)-1] == '}'
} | |
c25211 | strings.Contains(err.Error(), "not found"):
return true
default:
return false
}
} | |
c25212 | append(env, fmt.Sprintf("%s=%s", k, v))
}
return
} | |
c25213 |
lines[i] = prefix + l
}
return strings.Join(lines, "\n")
} | |
c25214 | select {
case <-timedout:
return errors.Errorf("timed out after %s", timeout)
case <-time.After(b.Duration()):
if IsListening(u) {
return nil
}
}
}
} | |
c25215 | return false
}
conn.Close()
return true
} | |
c25216 | s, ok := ps.Sys().(syscall.WaitStatus)
if ok {
return fmt.Sprintf("%d", s.ExitStatus())
}
}
return "?"
} | |
c25217 | %s\n", colors.Purple(fmt.Sprintf(msg, v...)))
} | |
c25218 |
term.ClearLine()
fmt.Printf("\r %s\n", colors.Purple(fmt.Sprintf(msg, v...)))
} | |
c25219 | \x1b[1m%s\x1b[m\n\n", fmt.Sprintf(msg, v...))
} | |
c25220 | fmt.Printf(" %s %s\n", colors.Purple(name+":"), fmt.Sprintf(msg, v...))
} | |
c25221 | %s\n", fmt.Sprintf(msg, v...))
} | |
c25222 | return float64(n)
case uint:
return float64(n)
case uint8:
return float64(n)
case uint16:
return float64(n)
case uint32:
return float64(n)
case uint64:
return float64(n)
case float32:
return float64(n)
case float64:
return n
default:
return math.NaN()
}
} | |
c25223 | int(time.Since(t) / time.Millisecond)
} | |
c25224 | time.Duration(v * float64(30*24*time.Hour))
case strings.HasSuffix(s, "M"):
var v float64
_, err = fmt.Fscanf(r, "%fM", &v)
d = time.Duration(v * float64(30*24*time.Hour))
default:
d, err = time.ParseDuration(s)
}
return
} | |
c25225 |
t := s.Text()
if strings.HasPrefix(t, "[") {
sections = append(sections, strings.Trim(t, "[]"))
}
}
err = s.Err()
return
} | |
c25226 | {
return RequestCost(requests) + DurationCost(ms, memory)
} | |
c25227 | function config: %s", err.Error())
continue
}
var relation ConfigRelation
relation.Function = fn
relation.Configuration = config.Configuration
relations = append(relations, relation)
}
args = append(args, getFunctionArnVars(relations)...)
args = append(args, getFunctionNameVars(relations)...)
args =... | |
c25228 | append(args, fmt.Sprintf("apex_function_%s=%s", rel.Function.Name, *rel.Configuration.FunctionArn))
}
return args
} | |
c25229 |
arns = append(arns, fmt.Sprintf("%s = %q", rel.Function.Name, *rel.Configuration.FunctionArn))
}
args = append(args, "-var")
args = append(args, fmt.Sprintf("apex_function_arns={ %s }", strings.Join(arns, ", ")))
return args
} | |
c25230 | {
names = append(names, fmt.Sprintf("%s = %q", rel.Function.Name, rel.Function.FunctionName))
}
args = append(args, "-var")
args = append(args, fmt.Sprintf("apex_function_names={ %s }", strings.Join(names, ", ")))
return args
} | |
c25231 | append(os.Environ(), p.functionEnvVars()...)
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Dir = p.Dir
return cmd.Run()
} | |
c25232 | m.Config,
FunctionName: fnName,
}
a[fnName] = metric.Collect()
}
return
} | |
c25233 | if cmd.Name() == name {
return cmd
}
}
return nil
} | |
c25234 | fmt.Printf("%s ", cmd.Name())
}
}
} | |
c25235 | *flag.Flag) {
if !f.Hidden {
fmt.Printf("--%s ", f.Name)
}
})
} | |
c25236 | fn.Log.WithField("runtime", runtime).Debug("inferred runtime")
fn.Runtime = runtime
return nil
}
}
return nil
} | |
c25237 | Provideriface {
return &Provider{
Session: session,
DryRun: dryRun,
}
} | |
c25238 |
return lambda.New(p.Session, cfg)
} else {
return lambda.New(p.Session)
}
} | |
c25239 | := zip.AddBytes("byline.js", shim.MustAsset("byline.js")); err != nil {
return err
}
}
return nil
} | |
c25240 |
fmt.Printf("apex_function_%s=%q\n", fn.Name, *config.Configuration.FunctionArn)
}
} | |
c25241 |
continue // ignore
}
aliaslist, err := fn.GetAliases()
if err != nil {
continue
}
var aliases string
for index, alias := range aliaslist.Aliases {
if index > 0 {
aliases += ", "
}
aliases += fmt.Sprintf("%s@v%s", *alias.Name, *alias.FunctionVersion)
}
if aliases == "" {
aliases ... | |
c25242 | len(q)/2 {
return q[n:]
}
copy(q[first:], q[first+n:])
return q[:len(q)-n]
} | |
c25243 | nil {
s.readLoopIPv4()
} else {
s.readLoopIPv6()
}
} | |
c25244 | nil {
l.monitorIPv4()
} else {
l.monitorIPv6()
}
} | |
c25245 | seg.wnd)
ptr = ikcp_encode32u(ptr, seg.ts)
ptr = ikcp_encode32u(ptr, seg.sn)
ptr = ikcp_encode32u(ptr, seg.una)
ptr = ikcp_encode32u(ptr, uint32(len(seg.data)))
atomic.AddUint64(&DefaultSnmp.OutSegs, 1)
return ptr
} | |
c25246 | IKCP_RTO_MIN
kcp.interval = IKCP_INTERVAL
kcp.ts_flush = IKCP_INTERVAL
kcp.ssthresh = IKCP_THRESH_INIT
kcp.dead_link = IKCP_DEADLINK
kcp.output = output
return kcp
} | |
c25247 | = xmitBuf.Get().([]byte)[:size]
return
} | |
c25248 |
xmitBuf.Put(seg.data)
seg.data = nil
}
} | |
c25249 | n < 0 {
return false
}
kcp.reserved = n
kcp.mss = kcp.mtu - IKCP_OVERHEAD - uint32(n)
return true
} | |
c25250 | for k := range kcp.rcv_queue {
seg := &kcp.rcv_queue[k]
length += len(seg.data)
if seg.frg == 0 {
break
}
}
return
} | |
c25251 |
copy(kcp.rcv_buf[insert_idx+1:], kcp.rcv_buf[insert_idx:])
kcp.rcv_buf[insert_idx] = newseg
}
}
// move available data from rcv_buf -> rcv_queue
count := 0
for k := range kcp.rcv_buf {
seg := &kcp.rcv_buf[k]
if seg.sn == kcp.rcv_nxt && len(kcp.rcv_queue) < int(kcp.rcv_wnd) {
kcp.rcv_nxt++
count+... | |
c25252 | == nil {
return -2
}
kcp.mtu = uint32(mtu)
kcp.mss = kcp.mtu - IKCP_OVERHEAD - uint32(kcp.reserved)
kcp.buffer = buffer
return 0
} | |
c25253 | len(kcp.snd_buf) + len(kcp.snd_queue)
} | |
c25254 | sess.output(buf[:size])
}
})
sess.kcp.ReserveBytes(sess.headerSize)
// register current session to the global updater,
// which call sess.update() periodically.
updater.addSession(sess)
if sess.l == nil { // it's a client connection
go sess.readLoop()
atomic.AddUint64(&DefaultSnmp.ActiveOpens, 1)
} el... | |
c25255 | {
s.kcp.flush(false)
}
s.mu.Unlock()
atomic.AddUint64(&DefaultSnmp.BytesSent, uint64(n))
return n, nil
}
var timeout *time.Timer
var c <-chan time.Time
if !s.wd.IsZero() {
if time.Now().After(s.wd) {
s.mu.Unlock()
return 0, errTimeout{}
}
delay := s.wd.Sub(time.Now())
timeo... | |
c25256 | defer s.mu.Unlock()
s.writeDelay = delay
} | |
c25257 |
defer s.mu.Unlock()
s.kcp.WndSize(sndwnd, rcvwnd)
} | |
c25258 | defer s.mu.Unlock()
s.ackNoDelay = nodelay
} | |
c25259 | defer s.mu.Unlock()
s.dup = dup
} | |
c25260 | nil {
if nc, ok := s.conn.(setReadBuffer); ok {
return nc.SetReadBuffer(bytes)
}
}
return errors.New(errInvalidOperation)
} | |
c25261 | interval = time.Duration(s.kcp.flush(false)) * time.Millisecond
if s.kcp.WaitSnd() < waitsnd {
s.notifyWriteEvent()
}
s.mu.Unlock()
return
} | |
c25262 | return nc.SetReadBuffer(bytes)
}
return errors.New(errInvalidOperation)
} | |
c25263 | return nc.SetWriteBuffer(bytes)
}
return errors.New(errInvalidOperation)
} | |
c25264 | {
return ipv6.NewConn(nc).SetTrafficClass(dscp)
}
}
return errors.New(errInvalidOperation)
} | |
c25265 | nil, &errTimeout{}
case c := <-l.chAccepts:
return c, nil
case <-l.die:
return nil, errors.New(errBrokenPipe)
}
} | |
c25266 | return l.conn.Close()
} | |
c25267 | delete(l.sessions, remote.String())
return true
}
return false
} | |
c25268 | if err != nil {
return nil, errors.Wrap(err, "net.ListenUDP")
}
return ServeConn(block, dataShards, parityShards, conn)
} | |
c25269 |
l.fecDecoder = newFECDecoder(rxFECMulti*(dataShards+parityShards), dataShards, parityShards)
// calculate header size
if l.block != nil {
l.headerSize += cryptHeaderSize
}
if l.fecDecoder != nil {
l.headerSize += fecHeaderSizePlus2
}
go l.monitor()
return l, nil
} | |
c25270 |
network = "udp"
}
conn, err := net.ListenUDP(network, nil)
if err != nil {
return nil, errors.Wrap(err, "net.DialUDP")
}
return NewConn(raddr, block, dataShards, parityShards, conn)
} | |
c25271 | uint32
binary.Read(rand.Reader, binary.LittleEndian, &convid)
return newUDPSession(convid, dataShards, parityShards, nil, conn, udpaddr, block), nil
} | |
c25272 |
fmt.Sprint(snmp.RetransSegs),
fmt.Sprint(snmp.FastRetransSegs),
fmt.Sprint(snmp.EarlyRetransSegs),
fmt.Sprint(snmp.LostSegs),
fmt.Sprint(snmp.RepeatSegs),
fmt.Sprint(snmp.FECParityShards),
fmt.Sprint(snmp.FECErrs),
fmt.Sprint(snmp.FECRecovered),
fmt.Sprint(snmp.FECShortShards),
}
} | |
c25273 |
d.OutPkts = atomic.LoadUint64(&s.OutPkts)
d.InSegs = atomic.LoadUint64(&s.InSegs)
d.OutSegs = atomic.LoadUint64(&s.OutSegs)
d.InBytes = atomic.LoadUint64(&s.InBytes)
d.OutBytes = atomic.LoadUint64(&s.OutBytes)
d.RetransSegs = atomic.LoadUint64(&s.RetransSegs)
d.FastRetransSegs = atomic.LoadUint64(&s.FastRetrans... | |
c25274 | 0)
atomic.StoreUint64(&s.FastRetransSegs, 0)
atomic.StoreUint64(&s.EarlyRetransSegs, 0)
atomic.StoreUint64(&s.LostSegs, 0)
atomic.StoreUint64(&s.RepeatSegs, 0)
atomic.StoreUint64(&s.FECParityShards, 0)
atomic.StoreUint64(&s.FECErrs, 0)
atomic.StoreUint64(&s.FECRecovered, 0)
atomic.StoreUint64(&s.FECShortShards... | |
c25275 | []byte(saltxor), 32, mtuLimit, sha1.New)
return c, nil
} | |
c25276 | 16:
encrypt16(block, dst, src, buf)
default:
encryptVariant(block, dst, src, buf)
}
} | |
c25277 |
if !ok {
return &yamuxAddr{"local"}
}
return addr.LocalAddr()
} | |
c25278 |
sendHdr: header(make([]byte, headerSize)),
sendErr: make(chan error, 1),
recvWindow: initialStreamWindow,
sendWindow: initialStreamWindow,
recvNotifyCh: make(chan struct{}, 1),
sendNotifyCh: make(chan struct{}, 1),
}
s.readDeadline.Store(time.Time{})
s.writeDeadline.Store(time.Time{})
ret... | |
c25279 |
// If there is no data available, block
s.recvLock.Lock()
if s.recvBuf == nil || s.recvBuf.Len() == 0 {
s.recvLock.Unlock()
goto WAIT
}
// Read any bytes
n, _ = s.recvBuf.Read(b)
s.recvLock.Unlock()
// Send a window update potentially
err = s.sendWindowUpdate()
return n, err
WAIT:
var timeout <-chan... | |
c25280 | total += n
if err != nil {
return total, err
}
}
return total, nil
} | |
c25281 | any
flags = s.sendFlags()
// Send up to our send window
max = min(window, uint32(len(b)))
body = bytes.NewReader(b[:max])
// Send the header
s.sendHdr.encode(typeData, flags, s.id, max)
if err = s.session.waitForSendErr(s.sendHdr, body, s.sendErr); err != nil {
return 0, err
}
// Reduce our send window
... | |
c25282 | {
case streamInit:
flags |= flagSYN
s.state = streamSYNSent
case streamSYNReceived:
flags |= flagACK
s.state = streamEstablished
}
return flags
} | |
c25283 | s.recvLock.Unlock()
return nil
}
// Update our window
s.recvWindow += delta
s.recvLock.Unlock()
// Send the header
s.controlHdr.encode(typeWindowUpdate, flags, s.id, delta)
if err := s.session.waitForSendErr(s.controlHdr, nil, s.controlErr); err != nil {
return err
}
return nil
} | |
c25284 | err := s.session.waitForSendErr(s.controlHdr, nil, s.controlErr); err != nil {
return err
}
return nil
} | |
c25285 | panic("unhandled state")
}
s.stateLock.Unlock()
return nil
SEND_CLOSE:
s.stateLock.Unlock()
s.sendClose()
s.notifyWaiting()
if closeStream {
s.session.closeStream(s.id)
}
return nil
} | |
c25286 |
s.stateLock.Unlock()
s.notifyWaiting()
} | |
c25287 | s.state = streamRemoteClose
s.notifyWaiting()
case streamLocalClose:
s.state = streamClosed
closeStream = true
s.notifyWaiting()
default:
s.session.logger.Printf("[ERR] yamux: unexpected FIN flag in state %d", s.state)
return ErrUnexpectedFlag
}
}
if flags&flagRST == flagRST {
s.state = str... | |
c25288 | atomic.AddUint32(&s.sendWindow, hdr.Length())
asyncNotify(s.sendNotifyCh)
return nil
} | |
c25289 | data frame.
// This way we can read in the whole packet without further allocations.
s.recvBuf = bytes.NewBuffer(make([]byte, 0, length))
}
if _, err := io.Copy(s.recvBuf, conn); err != nil {
s.session.logger.Printf("[ERR] yamux: Failed to read stream data: %v", err)
s.recvLock.Unlock()
return err
}
// ... | |
c25290 | }
if err := s.SetWriteDeadline(t); err != nil {
return err
}
return nil
} | |
c25291 | error {
s.writeDeadline.Store(t)
return nil
} | |
c25292 | s.recvBuf = nil
}
s.recvLock.Unlock()
} | |
c25293 | VerifyConfig(config); err != nil {
return nil, err
}
return newSession(config, conn, false), nil
} | |
c25294 | := VerifyConfig(config); err != nil {
return nil, err
}
return newSession(config, conn, true), nil
} | |
c25295 | make(chan sendReady, 64),
recvDoneCh: make(chan struct{}),
shutdownCh: make(chan struct{}),
}
if client {
s.nextStreamID = 1
} else {
s.nextStreamID = 2
}
go s.recv()
go s.send()
if config.EnableKeepAlive {
go s.keepalive()
}
return s
} | |
c25296 |
s.streamLock.Unlock()
return num
} | |
c25297 | return nil, err
}
return conn, nil
} | |
c25298 | := s.AcceptStream()
if err != nil {
return nil, err
}
return conn, err
} | |
c25299 | s.streamLock.Lock()
defer s.streamLock.Unlock()
for _, stream := range s.streams {
stream.forceClose()
}
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.