_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q25200 | aggregate | train | func aggregate(datapoints []*cloudwatch.Datapoint) int {
sum := 0.0
for _, datapoint := range datapoints {
sum += *datapoint.Sum
}
return int(sum)
} | go | {
"resource": ""
} |
q25201 | Error | train | func (e *HookError) Error() string {
return fmt.Sprintf("%s hook: %s", e.Hook, e.Output)
} | go | {
"resource": ""
} |
q25202 | Build | train | func (p *Plugin) Build(fn *function.Function, zip *archive.Zip) error {
return p.run("build", fn.Hooks.Build, fn)
} | go | {
"resource": ""
} |
q25203 | Deploy | train | func (p *Plugin) Deploy(fn *function.Function) error {
return p.run("deploy", fn.Hooks.Deploy, fn)
} | go | {
"resource": ""
} |
q25204 | run | train | func (p *Plugin) run(hook, command string, fn *function.Function) error {
if command == "" {
return nil
}
fn.Log.WithFields(log.Fields{
"hook": hook,
"command": command,
}).Debug("hook")
var cmd *exec.Cmd
if runtime.GOOS == "windows" {
cmd = exec.Command("cmd", "/c", command)
} else {
cmd = exec.C... | go | {
"resource": ""
} |
q25205 | ClearHeader | train | func ClearHeader(h http.Header) {
for k := range h {
if keepFields[k] {
continue
}
h.Del(k)
}
} | go | {
"resource": ""
} |
q25206 | ReadFileJSON | train | func ReadFileJSON(path string, v interface{}) error {
b, err := ioutil.ReadFile(path)
if err != nil {
return errors.Wrap(err, "reading")
}
if err := json.Unmarshal(b, &v); err != nil {
return errors.Wrap(err, "unmarshaling")
}
return nil
} | go | {
"resource": ""
} |
q25207 | Camelcase | train | func Camelcase(s string, v ...interface{}) string {
return name.CamelCase(fmt.Sprintf(s, v...), true)
} | go | {
"resource": ""
} |
q25208 | NewInlineProgressInt | train | func NewInlineProgressInt(total int) *progress.Bar {
b := progress.NewInt(total)
b.Template(`{{.Bar}} {{.Percent | printf "%0.0f"}}% {{.Text}}`)
b.Width = 20
b.StartDelimiter = colors.Gray("|")
b.EndDelimiter = colors.Gray("|")
b.Filled = colors.Purple("█")
b.Empty = colors.Gray(" ")
return b
} | go | {
"resource": ""
} |
q25209 | Fatal | train | func Fatal(err error) {
fmt.Fprintf(os.Stderr, "\n %s %s\n\n", colors.Red("Error:"), err)
os.Exit(1)
} | go | {
"resource": ""
} |
q25210 | IsJSON | train | func IsJSON(s string) bool {
return len(s) > 1 && s[0] == '{' && s[len(s)-1] == '}'
} | go | {
"resource": ""
} |
q25211 | IsNotFound | train | func IsNotFound(err error) bool {
switch {
case err == nil:
return false
case strings.Contains(err.Error(), "does not exist"):
return true
case strings.Contains(err.Error(), "not found"):
return true
default:
return false
}
} | go | {
"resource": ""
} |
q25212 | Env | train | func Env(m map[string]string) (env []string) {
for k, v := range m {
env = append(env, fmt.Sprintf("%s=%s", k, v))
}
return
} | go | {
"resource": ""
} |
q25213 | PrefixLines | train | func PrefixLines(s string, prefix string) string {
lines := strings.Split(s, "\n")
for i, l := range lines {
lines[i] = prefix + l
}
return strings.Join(lines, "\n")
} | go | {
"resource": ""
} |
q25214 | WaitForListen | train | func WaitForListen(u *url.URL, timeout time.Duration) error {
timedout := time.After(timeout)
b := backoff.Backoff{
Min: 100 * time.Millisecond,
Max: time.Second,
Factor: 1.5,
}
for {
select {
case <-timedout:
return errors.Errorf("timed out after %s", timeout)
case <-time.After(b.Duration())... | go | {
"resource": ""
} |
q25215 | IsListening | train | func IsListening(u *url.URL) bool {
conn, err := net.Dial("tcp", u.Host)
if err != nil {
return false
}
conn.Close()
return true
} | go | {
"resource": ""
} |
q25216 | ExitStatus | train | func ExitStatus(cmd *exec.Cmd, err error) string {
ps := cmd.ProcessState
if e, ok := err.(*exec.ExitError); ok {
ps = e.ProcessState
}
if ps != nil {
s, ok := ps.Sys().(syscall.WaitStatus)
if ok {
return fmt.Sprintf("%d", s.ExitStatus())
}
}
return "?"
} | go | {
"resource": ""
} |
q25217 | Log | train | func Log(msg string, v ...interface{}) {
fmt.Printf(" %s\n", colors.Purple(fmt.Sprintf(msg, v...)))
} | go | {
"resource": ""
} |
q25218 | LogClear | train | func LogClear(msg string, v ...interface{}) {
term.MoveUp(1)
term.ClearLine()
fmt.Printf("\r %s\n", colors.Purple(fmt.Sprintf(msg, v...)))
} | go | {
"resource": ""
} |
q25219 | LogTitle | train | func LogTitle(msg string, v ...interface{}) {
fmt.Printf("\n \x1b[1m%s\x1b[m\n\n", fmt.Sprintf(msg, v...))
} | go | {
"resource": ""
} |
q25220 | LogName | train | func LogName(name, msg string, v ...interface{}) {
fmt.Printf(" %s %s\n", colors.Purple(name+":"), fmt.Sprintf(msg, v...))
} | go | {
"resource": ""
} |
q25221 | LogListItem | train | func LogListItem(msg string, v ...interface{}) {
fmt.Printf(" • %s\n", fmt.Sprintf(msg, v...))
} | go | {
"resource": ""
} |
q25222 | ToFloat | train | func ToFloat(v interface{}) float64 {
switch n := v.(type) {
case int:
return float64(n)
case int8:
return float64(n)
case int16:
return float64(n)
case int32:
return float64(n)
case int64:
return float64(n)
case uint:
return float64(n)
case uint8:
return float64(n)
case uint16:
return float64(... | go | {
"resource": ""
} |
q25223 | MillisecondsSince | train | func MillisecondsSince(t time.Time) int {
return int(time.Since(t) / time.Millisecond)
} | go | {
"resource": ""
} |
q25224 | ParseDuration | train | func ParseDuration(s string) (d time.Duration, err error) {
r := strings.NewReader(s)
switch {
case strings.HasSuffix(s, "d"):
var v float64
_, err = fmt.Fscanf(r, "%fd", &v)
d = time.Duration(v * float64(24*time.Hour))
case strings.HasSuffix(s, "w"):
var v float64
_, err = fmt.Fscanf(r, "%fw", &v)
d =... | go | {
"resource": ""
} |
q25225 | ParseSections | train | func ParseSections(r io.Reader) (sections []string, err error) {
s := bufio.NewScanner(r)
for s.Scan() {
t := s.Text()
if strings.HasPrefix(t, "[") {
sections = append(sections, strings.Trim(t, "[]"))
}
}
err = s.Err()
return
} | go | {
"resource": ""
} |
q25226 | Cost | train | func Cost(requests, ms, memory int) float64 {
return RequestCost(requests) + DurationCost(ms, memory)
} | go | {
"resource": ""
} |
q25227 | functionVars | train | func (p *Proxy) functionVars() (args []string) {
args = append(args, "-var")
args = append(args, fmt.Sprintf("aws_region=%s", p.Region))
args = append(args, "-var")
args = append(args, fmt.Sprintf("apex_environment=%s", p.Environment))
if p.Role != "" {
args = append(args, "-var")
args = append(args, fmt.Sp... | go | {
"resource": ""
} |
q25228 | getFunctionArnVars | train | func getFunctionArnVars(relations []ConfigRelation) (args []string) {
log.Debugf("Generating the tfvar apex_function_FUNCTION")
for _, rel := range relations {
args = append(args, "-var")
args = append(args, fmt.Sprintf("apex_function_%s=%s", rel.Function.Name, *rel.Configuration.FunctionArn))
}
return args
} | go | {
"resource": ""
} |
q25229 | getFunctionArns | train | func getFunctionArns(relations []ConfigRelation) (args []string) {
log.Debugf("Generating the tfvar apex_function_arns")
var arns []string
for _, rel := range relations {
arns = append(arns, fmt.Sprintf("%s = %q", rel.Function.Name, *rel.Configuration.FunctionArn))
}
args = append(args, "-var")
args = append(ar... | go | {
"resource": ""
} |
q25230 | getFunctionNames | train | func getFunctionNames(relations []ConfigRelation) (args []string) {
log.Debugf("Generating the tfvar apex_function_names")
var names []string
for _, rel := range relations {
names = append(names, fmt.Sprintf("%s = %q", rel.Function.Name, rel.Function.FunctionName))
}
args = append(args, "-var")
args = append(ar... | go | {
"resource": ""
} |
q25231 | Run | train | func (p *Proxy) Run(command string, args ...string) error {
log.WithFields(log.Fields{
"command": command,
"args": args,
}).Debug("exec")
cmd := exec.Command(command, args...)
cmd.Env = append(os.Environ(), p.functionEnvVars()...)
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Di... | go | {
"resource": ""
} |
q25232 | Collect | train | func (m *Metrics) Collect() (a map[string]AggregatedMetrics) {
a = make(map[string]AggregatedMetrics)
for _, fnName := range m.FunctionNames {
metric := Metric{
Config: m.Config,
FunctionName: fnName,
}
a[fnName] = metric.Collect()
}
return
} | go | {
"resource": ""
} |
q25233 | find | train | func find(name string) *cobra.Command {
for _, cmd := range root.Command.Commands() {
if cmd.Name() == name {
return cmd
}
}
return nil
} | go | {
"resource": ""
} |
q25234 | rootCommands | train | func rootCommands() {
for _, cmd := range root.Command.Commands() {
if !cmd.Hidden {
fmt.Printf("%s ", cmd.Name())
}
}
} | go | {
"resource": ""
} |
q25235 | flags | train | func flags(cmd *cobra.Command) {
cmd.Flags().VisitAll(func(f *flag.Flag) {
if !f.Hidden {
fmt.Printf("--%s ", f.Name)
}
})
} | go | {
"resource": ""
} |
q25236 | Open | train | func (p *Plugin) Open(fn *function.Function) error {
if fn.Runtime != "" {
return nil
}
fn.Log.Debug("inferring runtime")
for name, runtime := range p.Files {
if _, err := os.Stat(filepath.Join(fn.Path, name)); err == nil {
fn.Log.WithField("runtime", runtime).Debug("inferred runtime")
fn.Runtime = runt... | go | {
"resource": ""
} |
q25237 | NewProvider | train | func NewProvider(session *session.Session, dryRun bool) Provideriface {
return &Provider{
Session: session,
DryRun: dryRun,
}
} | go | {
"resource": ""
} |
q25238 | NewService | train | func (p *Provider) NewService(cfg *aws.Config) lambdaiface.LambdaAPI {
if p.DryRun {
return dryrun.New(p.Session)
} else if cfg != nil {
return lambda.New(p.Session, cfg)
} else {
return lambda.New(p.Session)
}
} | go | {
"resource": ""
} |
q25239 | Build | train | func (p *Plugin) Build(fn *function.Function, zip *archive.Zip) error {
if fn.Shim {
fn.Log.Debug("add shim")
if err := zip.AddBytes("index.js", shim.MustAsset("index.js")); err != nil {
return err
}
if err := zip.AddBytes("byline.js", shim.MustAsset("byline.js")); err != nil {
return err
}
}
retu... | go | {
"resource": ""
} |
q25240 | outputTFvars | train | func outputTFvars() {
for _, fn := range root.Project.Functions {
config, err := fn.GetConfig()
if err != nil {
log.Debugf("can't fetch function config: %s", err.Error())
continue
}
fmt.Printf("apex_function_%s=%q\n", fn.Name, *config.Configuration.FunctionArn)
}
} | go | {
"resource": ""
} |
q25241 | outputList | train | func outputList() {
fmt.Println()
for _, fn := range root.Project.Functions {
awsFn, err := fn.GetConfigCurrent()
if awserr, ok := err.(awserr.Error); ok && awserr.Code() == "ResourceNotFoundException" {
fmt.Printf(" \033[%dm%s\033[0m (not deployed) \n", colors.Blue, fn.Name)
} else {
fmt.Printf(" \033... | go | {
"resource": ""
} |
q25242 | freeRange | train | func (dec *fecDecoder) freeRange(first, n int, q []fecPacket) []fecPacket {
for i := first; i < first+n; i++ { // recycle buffer
xmitBuf.Put([]byte(q[i]))
}
if first == 0 && n < len(q)/2 {
return q[n:]
}
copy(q[first:], q[first+n:])
return q[:len(q)-n]
} | go | {
"resource": ""
} |
q25243 | readLoop | train | func (s *UDPSession) readLoop() {
addr, _ := net.ResolveUDPAddr("udp", s.conn.LocalAddr().String())
if addr.IP.To4() != nil {
s.readLoopIPv4()
} else {
s.readLoopIPv6()
}
} | go | {
"resource": ""
} |
q25244 | monitor | train | func (l *Listener) monitor() {
addr, _ := net.ResolveUDPAddr("udp", l.conn.LocalAddr().String())
if addr.IP.To4() != nil {
l.monitorIPv4()
} else {
l.monitorIPv6()
}
} | go | {
"resource": ""
} |
q25245 | encode | train | func (seg *segment) encode(ptr []byte) []byte {
ptr = ikcp_encode32u(ptr, seg.conv)
ptr = ikcp_encode8u(ptr, seg.cmd)
ptr = ikcp_encode8u(ptr, seg.frg)
ptr = ikcp_encode16u(ptr, seg.wnd)
ptr = ikcp_encode32u(ptr, seg.ts)
ptr = ikcp_encode32u(ptr, seg.sn)
ptr = ikcp_encode32u(ptr, seg.una)
ptr = ikcp_encode32u(p... | go | {
"resource": ""
} |
q25246 | NewKCP | train | func NewKCP(conv uint32, output output_callback) *KCP {
kcp := new(KCP)
kcp.conv = conv
kcp.snd_wnd = IKCP_WND_SND
kcp.rcv_wnd = IKCP_WND_RCV
kcp.rmt_wnd = IKCP_WND_RCV
kcp.mtu = IKCP_MTU_DEF
kcp.mss = kcp.mtu - IKCP_OVERHEAD
kcp.buffer = make([]byte, kcp.mtu)
kcp.rx_rto = IKCP_RTO_DEF
kcp.rx_minrto = IKCP_RT... | go | {
"resource": ""
} |
q25247 | newSegment | train | func (kcp *KCP) newSegment(size int) (seg segment) {
seg.data = xmitBuf.Get().([]byte)[:size]
return
} | go | {
"resource": ""
} |
q25248 | delSegment | train | func (kcp *KCP) delSegment(seg *segment) {
if seg.data != nil {
xmitBuf.Put(seg.data)
seg.data = nil
}
} | go | {
"resource": ""
} |
q25249 | ReserveBytes | train | func (kcp *KCP) ReserveBytes(n int) bool {
if n >= int(kcp.mtu-IKCP_OVERHEAD) || n < 0 {
return false
}
kcp.reserved = n
kcp.mss = kcp.mtu - IKCP_OVERHEAD - uint32(n)
return true
} | go | {
"resource": ""
} |
q25250 | PeekSize | train | func (kcp *KCP) PeekSize() (length int) {
if len(kcp.rcv_queue) == 0 {
return -1
}
seg := &kcp.rcv_queue[0]
if seg.frg == 0 {
return len(seg.data)
}
if len(kcp.rcv_queue) < int(seg.frg+1) {
return -1
}
for k := range kcp.rcv_queue {
seg := &kcp.rcv_queue[k]
length += len(seg.data)
if seg.frg == 0... | go | {
"resource": ""
} |
q25251 | parse_data | train | func (kcp *KCP) parse_data(newseg segment) bool {
sn := newseg.sn
if _itimediff(sn, kcp.rcv_nxt+kcp.rcv_wnd) >= 0 ||
_itimediff(sn, kcp.rcv_nxt) < 0 {
return true
}
n := len(kcp.rcv_buf) - 1
insert_idx := 0
repeat := false
for i := n; i >= 0; i-- {
seg := &kcp.rcv_buf[i]
if seg.sn == sn {
repeat = tr... | go | {
"resource": ""
} |
q25252 | SetMtu | train | func (kcp *KCP) SetMtu(mtu int) int {
if mtu < 50 || mtu < IKCP_OVERHEAD {
return -1
}
if kcp.reserved >= int(kcp.mtu-IKCP_OVERHEAD) || kcp.reserved < 0 {
return -1
}
buffer := make([]byte, mtu)
if buffer == nil {
return -2
}
kcp.mtu = uint32(mtu)
kcp.mss = kcp.mtu - IKCP_OVERHEAD - uint32(kcp.reserved)... | go | {
"resource": ""
} |
q25253 | WaitSnd | train | func (kcp *KCP) WaitSnd() int {
return len(kcp.snd_buf) + len(kcp.snd_queue)
} | go | {
"resource": ""
} |
q25254 | newUDPSession | train | func newUDPSession(conv uint32, dataShards, parityShards int, l *Listener, conn net.PacketConn, remote net.Addr, block BlockCrypt) *UDPSession {
sess := new(UDPSession)
sess.die = make(chan struct{})
sess.nonce = new(nonceAES128)
sess.nonce.Init()
sess.chReadEvent = make(chan struct{}, 1)
sess.chWriteEvent = make... | go | {
"resource": ""
} |
q25255 | WriteBuffers | train | func (s *UDPSession) WriteBuffers(v [][]byte) (n int, err error) {
for {
s.mu.Lock()
if s.isClosed {
s.mu.Unlock()
return 0, errors.New(errBrokenPipe)
}
if s.kcp.WaitSnd() < int(s.kcp.snd_wnd) {
for _, b := range v {
n += len(b)
for {
if len(b) <= int(s.kcp.mss) {
s.kcp.Send(b)
... | go | {
"resource": ""
} |
q25256 | SetWriteDelay | train | func (s *UDPSession) SetWriteDelay(delay bool) {
s.mu.Lock()
defer s.mu.Unlock()
s.writeDelay = delay
} | go | {
"resource": ""
} |
q25257 | SetWindowSize | train | func (s *UDPSession) SetWindowSize(sndwnd, rcvwnd int) {
s.mu.Lock()
defer s.mu.Unlock()
s.kcp.WndSize(sndwnd, rcvwnd)
} | go | {
"resource": ""
} |
q25258 | SetACKNoDelay | train | func (s *UDPSession) SetACKNoDelay(nodelay bool) {
s.mu.Lock()
defer s.mu.Unlock()
s.ackNoDelay = nodelay
} | go | {
"resource": ""
} |
q25259 | SetDUP | train | func (s *UDPSession) SetDUP(dup int) {
s.mu.Lock()
defer s.mu.Unlock()
s.dup = dup
} | go | {
"resource": ""
} |
q25260 | SetReadBuffer | train | func (s *UDPSession) SetReadBuffer(bytes int) error {
s.mu.Lock()
defer s.mu.Unlock()
if s.l == nil {
if nc, ok := s.conn.(setReadBuffer); ok {
return nc.SetReadBuffer(bytes)
}
}
return errors.New(errInvalidOperation)
} | go | {
"resource": ""
} |
q25261 | update | train | func (s *UDPSession) update() (interval time.Duration) {
s.mu.Lock()
waitsnd := s.kcp.WaitSnd()
interval = time.Duration(s.kcp.flush(false)) * time.Millisecond
if s.kcp.WaitSnd() < waitsnd {
s.notifyWriteEvent()
}
s.mu.Unlock()
return
} | go | {
"resource": ""
} |
q25262 | SetReadBuffer | train | func (l *Listener) SetReadBuffer(bytes int) error {
if nc, ok := l.conn.(setReadBuffer); ok {
return nc.SetReadBuffer(bytes)
}
return errors.New(errInvalidOperation)
} | go | {
"resource": ""
} |
q25263 | SetWriteBuffer | train | func (l *Listener) SetWriteBuffer(bytes int) error {
if nc, ok := l.conn.(setWriteBuffer); ok {
return nc.SetWriteBuffer(bytes)
}
return errors.New(errInvalidOperation)
} | go | {
"resource": ""
} |
q25264 | SetDSCP | train | func (l *Listener) SetDSCP(dscp int) error {
if nc, ok := l.conn.(net.Conn); ok {
addr, _ := net.ResolveUDPAddr("udp", nc.LocalAddr().String())
if addr.IP.To4() != nil {
return ipv4.NewConn(nc).SetTOS(dscp << 2)
} else {
return ipv6.NewConn(nc).SetTrafficClass(dscp)
}
}
return errors.New(errInvalidOper... | go | {
"resource": ""
} |
q25265 | AcceptKCP | train | func (l *Listener) AcceptKCP() (*UDPSession, error) {
var timeout <-chan time.Time
if tdeadline, ok := l.rd.Load().(time.Time); ok && !tdeadline.IsZero() {
timeout = time.After(tdeadline.Sub(time.Now()))
}
select {
case <-timeout:
return nil, &errTimeout{}
case c := <-l.chAccepts:
return c, nil
case <-l.d... | go | {
"resource": ""
} |
q25266 | Close | train | func (l *Listener) Close() error {
close(l.die)
return l.conn.Close()
} | go | {
"resource": ""
} |
q25267 | closeSession | train | func (l *Listener) closeSession(remote net.Addr) (ret bool) {
l.sessionLock.Lock()
defer l.sessionLock.Unlock()
if _, ok := l.sessions[remote.String()]; ok {
delete(l.sessions, remote.String())
return true
}
return false
} | go | {
"resource": ""
} |
q25268 | ListenWithOptions | train | func ListenWithOptions(laddr string, block BlockCrypt, dataShards, parityShards int) (*Listener, error) {
udpaddr, err := net.ResolveUDPAddr("udp", laddr)
if err != nil {
return nil, errors.Wrap(err, "net.ResolveUDPAddr")
}
conn, err := net.ListenUDP("udp", udpaddr)
if err != nil {
return nil, errors.Wrap(err,... | go | {
"resource": ""
} |
q25269 | ServeConn | train | func ServeConn(block BlockCrypt, dataShards, parityShards int, conn net.PacketConn) (*Listener, error) {
l := new(Listener)
l.conn = conn
l.sessions = make(map[string]*UDPSession)
l.chAccepts = make(chan *UDPSession, acceptBacklog)
l.chSessionClosed = make(chan net.Addr)
l.die = make(chan struct{})
l.dataShards ... | go | {
"resource": ""
} |
q25270 | DialWithOptions | train | func DialWithOptions(raddr string, block BlockCrypt, dataShards, parityShards int) (*UDPSession, error) {
// network type detection
udpaddr, err := net.ResolveUDPAddr("udp", raddr)
if err != nil {
return nil, errors.Wrap(err, "net.ResolveUDPAddr")
}
network := "udp4"
if udpaddr.IP.To4() == nil {
network = "ud... | go | {
"resource": ""
} |
q25271 | NewConn | train | func NewConn(raddr string, block BlockCrypt, dataShards, parityShards int, conn net.PacketConn) (*UDPSession, error) {
udpaddr, err := net.ResolveUDPAddr("udp", raddr)
if err != nil {
return nil, errors.Wrap(err, "net.ResolveUDPAddr")
}
var convid uint32
binary.Read(rand.Reader, binary.LittleEndian, &convid)
r... | go | {
"resource": ""
} |
q25272 | ToSlice | train | func (s *Snmp) ToSlice() []string {
snmp := s.Copy()
return []string{
fmt.Sprint(snmp.BytesSent),
fmt.Sprint(snmp.BytesReceived),
fmt.Sprint(snmp.MaxConn),
fmt.Sprint(snmp.ActiveOpens),
fmt.Sprint(snmp.PassiveOpens),
fmt.Sprint(snmp.CurrEstab),
fmt.Sprint(snmp.InErrs),
fmt.Sprint(snmp.InCsumErrors),
... | go | {
"resource": ""
} |
q25273 | Copy | train | func (s *Snmp) Copy() *Snmp {
d := newSnmp()
d.BytesSent = atomic.LoadUint64(&s.BytesSent)
d.BytesReceived = atomic.LoadUint64(&s.BytesReceived)
d.MaxConn = atomic.LoadUint64(&s.MaxConn)
d.ActiveOpens = atomic.LoadUint64(&s.ActiveOpens)
d.PassiveOpens = atomic.LoadUint64(&s.PassiveOpens)
d.CurrEstab = atomic.Loa... | go | {
"resource": ""
} |
q25274 | Reset | train | func (s *Snmp) Reset() {
atomic.StoreUint64(&s.BytesSent, 0)
atomic.StoreUint64(&s.BytesReceived, 0)
atomic.StoreUint64(&s.MaxConn, 0)
atomic.StoreUint64(&s.ActiveOpens, 0)
atomic.StoreUint64(&s.PassiveOpens, 0)
atomic.StoreUint64(&s.CurrEstab, 0)
atomic.StoreUint64(&s.InErrs, 0)
atomic.StoreUint64(&s.InCsumErr... | go | {
"resource": ""
} |
q25275 | NewSimpleXORBlockCrypt | train | func NewSimpleXORBlockCrypt(key []byte) (BlockCrypt, error) {
c := new(simpleXORBlockCrypt)
c.xortbl = pbkdf2.Key(key, []byte(saltxor), 32, mtuLimit, sha1.New)
return c, nil
} | go | {
"resource": ""
} |
q25276 | encrypt | train | func encrypt(block cipher.Block, dst, src, buf []byte) {
switch block.BlockSize() {
case 8:
encrypt8(block, dst, src, buf)
case 16:
encrypt16(block, dst, src, buf)
default:
encryptVariant(block, dst, src, buf)
}
} | go | {
"resource": ""
} |
q25277 | LocalAddr | train | func (s *Session) LocalAddr() net.Addr {
addr, ok := s.conn.(hasAddr)
if !ok {
return &yamuxAddr{"local"}
}
return addr.LocalAddr()
} | go | {
"resource": ""
} |
q25278 | newStream | train | func newStream(session *Session, id uint32, state streamState) *Stream {
s := &Stream{
id: id,
session: session,
state: state,
controlHdr: header(make([]byte, headerSize)),
controlErr: make(chan error, 1),
sendHdr: header(make([]byte, headerSize)),
sendErr: make(chan e... | go | {
"resource": ""
} |
q25279 | Read | train | func (s *Stream) Read(b []byte) (n int, err error) {
defer asyncNotify(s.recvNotifyCh)
START:
s.stateLock.Lock()
switch s.state {
case streamLocalClose:
fallthrough
case streamRemoteClose:
fallthrough
case streamClosed:
s.recvLock.Lock()
if s.recvBuf == nil || s.recvBuf.Len() == 0 {
s.recvLock.Unlock()... | go | {
"resource": ""
} |
q25280 | Write | train | func (s *Stream) Write(b []byte) (n int, err error) {
s.sendLock.Lock()
defer s.sendLock.Unlock()
total := 0
for total < len(b) {
n, err := s.write(b[total:])
total += n
if err != nil {
return total, err
}
}
return total, nil
} | go | {
"resource": ""
} |
q25281 | write | train | func (s *Stream) write(b []byte) (n int, err error) {
var flags uint16
var max uint32
var body io.Reader
START:
s.stateLock.Lock()
switch s.state {
case streamLocalClose:
fallthrough
case streamClosed:
s.stateLock.Unlock()
return 0, ErrStreamClosed
case streamReset:
s.stateLock.Unlock()
return 0, ErrC... | go | {
"resource": ""
} |
q25282 | sendFlags | train | func (s *Stream) sendFlags() uint16 {
s.stateLock.Lock()
defer s.stateLock.Unlock()
var flags uint16
switch s.state {
case streamInit:
flags |= flagSYN
s.state = streamSYNSent
case streamSYNReceived:
flags |= flagACK
s.state = streamEstablished
}
return flags
} | go | {
"resource": ""
} |
q25283 | sendWindowUpdate | train | func (s *Stream) sendWindowUpdate() error {
s.controlHdrLock.Lock()
defer s.controlHdrLock.Unlock()
// Determine the delta update
max := s.session.config.MaxStreamWindowSize
var bufLen uint32
s.recvLock.Lock()
if s.recvBuf != nil {
bufLen = uint32(s.recvBuf.Len())
}
delta := (max - bufLen) - s.recvWindow
... | go | {
"resource": ""
} |
q25284 | sendClose | train | func (s *Stream) sendClose() error {
s.controlHdrLock.Lock()
defer s.controlHdrLock.Unlock()
flags := s.sendFlags()
flags |= flagFIN
s.controlHdr.encode(typeWindowUpdate, flags, s.id, 0)
if err := s.session.waitForSendErr(s.controlHdr, nil, s.controlErr); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q25285 | Close | train | func (s *Stream) Close() error {
closeStream := false
s.stateLock.Lock()
switch s.state {
// Opened means we need to signal a close
case streamSYNSent:
fallthrough
case streamSYNReceived:
fallthrough
case streamEstablished:
s.state = streamLocalClose
goto SEND_CLOSE
case streamLocalClose:
case streamR... | go | {
"resource": ""
} |
q25286 | forceClose | train | func (s *Stream) forceClose() {
s.stateLock.Lock()
s.state = streamClosed
s.stateLock.Unlock()
s.notifyWaiting()
} | go | {
"resource": ""
} |
q25287 | processFlags | train | func (s *Stream) processFlags(flags uint16) error {
// Close the stream without holding the state lock
closeStream := false
defer func() {
if closeStream {
s.session.closeStream(s.id)
}
}()
s.stateLock.Lock()
defer s.stateLock.Unlock()
if flags&flagACK == flagACK {
if s.state == streamSYNSent {
s.st... | go | {
"resource": ""
} |
q25288 | incrSendWindow | train | func (s *Stream) incrSendWindow(hdr header, flags uint16) error {
if err := s.processFlags(flags); err != nil {
return err
}
// Increase window, unblock a sender
atomic.AddUint32(&s.sendWindow, hdr.Length())
asyncNotify(s.sendNotifyCh)
return nil
} | go | {
"resource": ""
} |
q25289 | readData | train | func (s *Stream) readData(hdr header, flags uint16, conn io.Reader) error {
if err := s.processFlags(flags); err != nil {
return err
}
// Check that our recv window is not exceeded
length := hdr.Length()
if length == 0 {
return nil
}
// Wrap in a limited reader
conn = &io.LimitedReader{R: conn, N: int64(l... | go | {
"resource": ""
} |
q25290 | SetDeadline | train | func (s *Stream) SetDeadline(t time.Time) error {
if err := s.SetReadDeadline(t); err != nil {
return err
}
if err := s.SetWriteDeadline(t); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q25291 | SetWriteDeadline | train | func (s *Stream) SetWriteDeadline(t time.Time) error {
s.writeDeadline.Store(t)
return nil
} | go | {
"resource": ""
} |
q25292 | Shrink | train | func (s *Stream) Shrink() {
s.recvLock.Lock()
if s.recvBuf != nil && s.recvBuf.Len() == 0 {
s.recvBuf = nil
}
s.recvLock.Unlock()
} | go | {
"resource": ""
} |
q25293 | Server | train | func Server(conn io.ReadWriteCloser, config *Config) (*Session, error) {
if config == nil {
config = DefaultConfig()
}
if err := VerifyConfig(config); err != nil {
return nil, err
}
return newSession(config, conn, false), nil
} | go | {
"resource": ""
} |
q25294 | Client | train | func Client(conn io.ReadWriteCloser, config *Config) (*Session, error) {
if config == nil {
config = DefaultConfig()
}
if err := VerifyConfig(config); err != nil {
return nil, err
}
return newSession(config, conn, true), nil
} | go | {
"resource": ""
} |
q25295 | newSession | train | func newSession(config *Config, conn io.ReadWriteCloser, client bool) *Session {
logger := config.Logger
if logger == nil {
logger = log.New(config.LogOutput, "", log.LstdFlags)
}
s := &Session{
config: config,
logger: logger,
conn: conn,
bufRead: bufio.NewReader(conn),
pings: mak... | go | {
"resource": ""
} |
q25296 | NumStreams | train | func (s *Session) NumStreams() int {
s.streamLock.Lock()
num := len(s.streams)
s.streamLock.Unlock()
return num
} | go | {
"resource": ""
} |
q25297 | Open | train | func (s *Session) Open() (net.Conn, error) {
conn, err := s.OpenStream()
if err != nil {
return nil, err
}
return conn, nil
} | go | {
"resource": ""
} |
q25298 | Accept | train | func (s *Session) Accept() (net.Conn, error) {
conn, err := s.AcceptStream()
if err != nil {
return nil, err
}
return conn, err
} | go | {
"resource": ""
} |
q25299 | Close | train | func (s *Session) Close() error {
s.shutdownLock.Lock()
defer s.shutdownLock.Unlock()
if s.shutdown {
return nil
}
s.shutdown = true
if s.shutdownErr == nil {
s.shutdownErr = ErrSessionShutdown
}
close(s.shutdownCh)
s.conn.Close()
<-s.recvDoneCh
s.streamLock.Lock()
defer s.streamLock.Unlock()
for _, ... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.