id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c25300 | = err
}
s.shutdownLock.Unlock()
s.Close()
} | |
c25301 | s.waitForSend(s.goAway(goAwayNormal), nil)
} | |
c25302 | header(make([]byte, headerSize))
hdr.encode(typeGoAway, 0, 0, reason)
return hdr
} | |
c25303 | <-ch:
case <-time.After(s.config.ConnectionWriteTimeout):
s.pingLock.Lock()
delete(s.pings, id) // Ignore it if a response comes later.
s.pingLock.Unlock()
return 0, ErrTimeout
case <-s.shutdownCh:
return 0, ErrSessionShutdown
}
// Compute the RTT
return time.Now().Sub(start), nil
} | |
c25304 | failed: %v", err)
s.exitErr(ErrKeepAliveTimeout)
}
return
}
case <-s.shutdownCh:
return
}
}
} | |
c25305 | return s.waitForSendErr(hdr, body, errCh)
} | |
c25306 |
return ErrConnectionWriteTimeout
}
select {
case err := <-errCh:
return err
case <-s.shutdownCh:
return ErrSessionShutdown
case <-timer.C:
return ErrConnectionWriteTimeout
}
} | |
c25307 | }()
select {
case s.sendCh <- sendReady{Hdr: hdr}:
return nil
case <-s.shutdownCh:
return ErrSessionShutdown
case <-timer.C:
return ErrConnectionWriteTimeout
}
} | |
c25308 | err != nil {
s.logger.Printf("[ERR] yamux: Failed to write body: %v", err)
asyncSendErr(ready.Err, err)
s.exitErr(err)
return
}
}
// No error, successful send
asyncSendErr(ready.Err, nil)
case <-s.shutdownCh:
return
}
}
} | |
c25309 | nil {
s.exitErr(err)
}
} | |
c25310 | if hdr.Version() != protoVersion {
s.logger.Printf("[ERR] yamux: Invalid protocol version: %d", hdr.Version())
return ErrInvalidVersion
}
mt := hdr.MsgType()
if mt < typeData || mt > typeGoAway {
return ErrInvalidMsgType
}
if err := handlers[mt](s, hdr); err != nil {
return err
}
}
} | |
c25311 | if err := stream.incrSendWindow(hdr, flags); err != nil {
if sendErr := s.sendNoWait(s.goAway(goAwayProtoErr)); sendErr != nil {
s.logger.Printf("[WARN] yamux: failed to send go away: %v", sendErr)
}
return err
}
return nil
}
// Read the new data
if err := stream.readData(hdr, flags, s.bufRead); e... | |
c25312 | failed to send ping reply: %v", err)
}
}()
return nil
}
// Handle a response
s.pingLock.Lock()
ch := s.pings[pingID]
if ch != nil {
delete(s.pings, pingID)
close(ch)
}
s.pingLock.Unlock()
return nil
} | |
c25313 | go away")
return fmt.Errorf("remote yamux internal error")
default:
s.logger.Printf("[ERR] yamux: received unexpected go away")
return fmt.Errorf("unexpected go away received")
}
return nil
} | |
c25314 | return ErrDuplicateStream
}
// Register the stream
s.streams[id] = stream
// Check if we've exceeded the backlog
select {
case s.acceptCh <- stream:
return nil
default:
// Backlog exceeded! RST the stream
s.logger.Printf("[WARN] yamux: backlog exceeded, forcing connection reset")
delete(s.streams, id... | |
c25315 | s.logger.Printf("[ERR] yamux: SYN tracking out of sync")
}
}
delete(s.streams, id)
s.streamLock.Unlock()
} | |
c25316 | config.TickInterval, config.Prefix, config.GraphiteAddr)
} | |
c25317 | circuitBreakers[name]; ok {
return cb, false, nil
}
circuitBreakers[name] = newCircuitBreaker(name)
} else {
defer circuitBreakersMutex.RUnlock()
}
return circuitBreakers[name], !ok, nil
} | |
c25318 |
cb.executorPool.Metrics.Reset()
delete(circuitBreakers, name)
}
} | |
c25319 | = name
c.metrics = newMetricExchange(name)
c.executorPool = newExecutorPool(name)
c.mutex = &sync.RWMutex{}
return c
} | |
c25320 | {
return err
}
circuit.forceOpen = toggle
return nil
} | |
c25321 |
if !circuit.metrics.IsHealthy(time.Now()) {
// too many failures, open the circuit
circuit.setOpen()
return true
}
return false
} | |
c25322 | eventTypes,
Start: start,
RunDuration: runDuration,
ConcurrencyInUse: concurrencyInUse,
}:
default:
return CircuitError{Message: fmt.Sprintf("metrics channel (%v) is at capacity", circuit.Name)}
}
return nil
} | |
c25323 | make(map[int64]*numberBucket),
Mutex: &sync.RWMutex{},
}
return r
} | |
c25324 |
defer r.Mutex.Unlock()
b := r.getCurrentBucket()
b.Value += i
r.removeOldBuckets()
} | |
c25325 | b.Value {
b.Value = n
}
r.removeOldBuckets()
} | |
c25326 | // TODO: configurable rolling window
if timestamp >= now.Unix()-10 {
sum += bucket.Value
}
}
return sum
} | |
c25327 | := range r.Buckets {
// TODO: configurable rolling window
if timestamp >= now.Unix()-10 {
if bucket.Value > max {
max = bucket.Value
}
}
}
return max
} | |
c25328 | fallbackFuncC
if fallback != nil {
fallbackC = func(ctx context.Context, err error) error {
return fallback(err)
}
}
return GoC(context.Background(), name, runC, fallbackC)
} | |
c25329 | done <- struct{}{}
return nil
}
var errChan chan error
if fallback == nil {
errChan = GoC(ctx, name, r, nil)
} else {
errChan = GoC(ctx, name, r, f)
}
select {
case <-done:
return nil
case err := <-errChan:
return err
}
} | |
c25330 | == ErrTimeout {
eventType = "timeout"
} else if err == context.Canceled {
eventType = "context_canceled"
} else if err == context.DeadlineExceeded {
eventType = "context_deadline_exceeded"
}
c.reportEvent(eventType)
fallbackErr := c.tryFallback(ctx, err)
if fallbackErr != nil {
c.errChan <- fallbackErr
... | |
c25331 | {
for k, v := range cmds {
ConfigureCommand(k, v)
}
} | |
c25332 | {
errorPercent = config.ErrorPercentThreshold
}
circuitSettings[name] = &Settings{
Timeout: time.Duration(timeout) * time.Millisecond,
MaxConcurrentRequests: max,
RequestVolumeThreshold: uint64(volume),
SleepWindow: time.Duration(sleep) * time.Millisecond,
ErrorPercentThreshol... | |
c25333 | defer d.mutex.RUnlock()
return d.numRequests
} | |
c25334 | defer d.mutex.RUnlock()
return d.errors
} | |
c25335 | defer d.mutex.RUnlock()
return d.successes
} | |
c25336 | defer d.mutex.RUnlock()
return d.failures
} | |
c25337 | defer d.mutex.RUnlock()
return d.rejects
} | |
c25338 | defer d.mutex.RUnlock()
return d.shortCircuits
} | |
c25339 | defer d.mutex.RUnlock()
return d.timeouts
} | |
c25340 | defer d.mutex.RUnlock()
return d.fallbackSuccesses
} | |
c25341 | defer d.mutex.RUnlock()
return d.fallbackFailures
} | |
c25342 | defer d.mutex.RUnlock()
return d.totalDuration
} | |
c25343 | defer d.mutex.RUnlock()
return d.runDuration
} | |
c25344 | rolling.NewNumber()
d.failures = rolling.NewNumber()
d.timeouts = rolling.NewNumber()
d.fallbackSuccesses = rolling.NewNumber()
d.fallbackFailures = rolling.NewNumber()
d.contextCanceled = rolling.NewNumber()
d.contextDeadlineExceeded = rolling.NewNumber()
d.totalDuration = rolling.NewTiming()
d.runDuration = ... | |
c25345 | make(map[int64]*timingBucket),
Mutex: &sync.RWMutex{},
}
return r
} | |
c25346 |
for _, d := range b.Durations {
durations = append(durations, d)
}
}
}
sort.Sort(durations)
r.CachedSortedDurations = durations
r.LastCachedTime = time.Now().UnixNano()
return r.CachedSortedDurations
} | |
c25347 | = append(b.Durations, duration)
r.removeOldBuckets()
} | |
c25348 | if length <= 0 {
return 0
}
pos := r.ordinal(len(sortedDurations), p) - 1
return uint32(sortedDurations[pos].Nanoseconds() / 1000000)
} | |
c25349 | sortedDurations {
sum += d
}
length := int64(len(sortedDurations))
if length == 0 {
return 0
}
return uint32(sum.Nanoseconds()/length) / 1000000
} | |
c25350 | !ok {
panic("Default metric collector is not registered correctly. The default metric collector must be registered first.")
}
return collection
} | |
c25351 | sh.done = make(chan struct{})
go sh.loop()
} | |
c25352 | metricCollectorInitializer := range m.registry {
metrics[i] = metricCollectorInitializer(name)
}
return metrics
} | |
c25353 | MetricCollector) {
m.lock.Lock()
defer m.lock.Unlock()
m.registry = append(m.registry, initMetricCollector)
} | |
c25354 | err
} else if comp == 1 {
return false, nil
}
return true, nil
} | |
c25355 | if v1S > v2S {
return 1, nil
}
if v1S < v2S {
return -1, nil
}
}
return 0, nil
} | |
c25356 | if err != nil {
return nil
}
version[idx] = vS
}
return version
} | |
c25357 | {
return nil, ErrNoServiceSystemDetected
}
return system.New(i, c)
} | |
c25358 | := v.(bool); is {
return castValue
}
}
return defaultValue
} | |
c25359 | err = s.Uninstall()
default:
err = fmt.Errorf("Unknown action %s", action)
}
if err != nil {
return fmt.Errorf("Failed to %s %v: %v", action, s, err)
}
return nil
} | |
c25360 | l.send(l.ev.Error(3, fmt.Sprintf(format, a...)))
} | |
c25361 | l.send(l.ev.Warning(2, fmt.Sprintf(format, a...)))
} | |
c25362 | l.send(l.ev.Info(1, fmt.Sprintf(format, a...)))
} | |
c25363 | l.send(l.ev.Error(eventID, fmt.Sprint(v...)))
} | |
c25364 | l.send(l.ev.Warning(eventID, fmt.Sprint(v...)))
} | |
c25365 | l.send(l.ev.Info(eventID, fmt.Sprint(v...)))
} | |
c25366 |
return l.send(l.ev.Error(eventID, fmt.Sprintf(format, a...)))
} | |
c25367 |
return l.send(l.ev.Warning(eventID, fmt.Sprintf(format, a...)))
} | |
c25368 |
return l.send(l.ev.Info(eventID, fmt.Sprintf(format, a...)))
} | |
c25369 | key.GetStringValue("WaitToKillServiceTimeout")
if err != nil {
return defaultTimeout
}
v, err := strconv.Atoi(sv)
if err != nil {
return defaultTimeout
}
return time.Millisecond * time.Duration(v)
} | |
c25370 |
v.EditDelete(false)
case key == KeyInsert:
v.Overwrite = !v.Overwrite
case key == KeyEnter:
v.EditNewLine()
case key == KeyArrowDown:
v.MoveCursor(0, 1, false)
case key == KeyArrowUp:
v.MoveCursor(0, -1, false)
case key == KeyArrowLeft:
v.MoveCursor(-1, 0, false)
case key == KeyArrowRight:
v.MoveCu... | |
c25371 | v.writeRune(v.cx, v.cy, ch)
v.MoveCursor(1, 0, true)
} | |
c25372 | true)
}
} else { // wrapped line
v.deleteRune(len(v.viewLines[y-1].line)-1, v.cy-1)
v.MoveCursor(-1, 0, true)
}
} else { // middle/end of the line
v.deleteRune(v.cx-1, v.cy)
v.MoveCursor(-1, 0, true)
}
} else {
if x == len(v.viewLines[y].line) { // end of the line
v.mergeLines(v.cy)
... | |
c25373 | v.cy)
v.ox = 0
v.cx = 0
v.MoveCursor(0, 1, true)
} | |
c25374 | don't need to merge anything
v.lines[y] = append(v.lines[y], v.lines[y+1]...)
v.lines = append(v.lines[:y+1], v.lines[y+2:]...)
}
return nil
} | |
c25375 | key,
ch: ch,
mod: mod,
handler: handler,
}
return kb
} | |
c25376 | mod Modifier) bool {
return kb.key == key && kb.ch == ch && kb.mod == mod
} | |
c25377 |
return v != nil && kb.viewName == v.name
} | |
c25378 |
str += string(c.chr)
}
return str
} | |
c25379 |
Editor: DefaultEditor,
tainted: true,
ei: newEscapeInterpreter(mode),
}
return v
} | |
c25380 | - v.x0 - 1, v.y1 - v.y0 - 1
} | |
c25381 | err != nil {
return err
}
_, rcy, err = v.realPosition(v.cx, v.cy)
if err != nil {
return err
}
}
if v.Mask != 0 {
fgColor = v.FgColor
bgColor = v.BgColor
ch = v.Mask
} else if v.Highlight && ry == rcy {
fgColor = v.SelFgColor
bgColor = v.SelBgColor
}
termbox.SetCell(v.x0+x+1, v.y0+y+1, ... | |
c25382 | || x >= maxX || y < 0 || y >= maxY {
return errors.New("invalid point")
}
v.cx = x
v.cy = y
return nil
} | |
c25383 |
return v.cx, v.cy
} | |
c25384 | y < 0 {
return errors.New("invalid point")
}
v.ox = x
v.oy = y
return nil
} | |
c25385 |
return v.ox, v.oy
} | |
c25386 | if cells == nil {
continue
}
nl := len(v.lines)
if nl > 0 {
v.lines[nl-1] = append(v.lines[nl-1], cells...)
} else {
v.lines = append(v.lines, cells)
}
}
}
return len(p), nil
} | |
c25387 | {
if isEscape {
return nil
}
c := cell{
fgColor: v.ei.curFgColor,
bgColor: v.ei.curBgColor,
chr: ch,
}
cells = append(cells, c)
}
return cells
} | |
c25388 | vline := viewLine{linesX: n, linesY: i, line: line[n : n+maxX]}
v.viewLines = append(v.viewLines, vline)
}
}
}
} else {
vline := viewLine{linesX: 0, linesY: i, line: line}
v.viewLines = append(v.viewLines, vline)
}
}
v.tainted = false
}
if v.Autoscroll && len(v.viewLines) >... | |
c25389 | = nil
v.viewLines = nil
v.readOffset = 0
v.clearRunes()
} | |
c25390 | y < maxY; y++ {
termbox.SetCell(v.x0+x+1, v.y0+y+1, ' ',
termbox.Attribute(v.FgColor), termbox.Attribute(v.BgColor))
}
}
} | |
c25391 |
str = strings.Replace(str, "\x00", " ", -1)
lines[i] = str
}
return lines
} | |
c25392 | }
return strings.Replace(str, "\x00", " ", -1)
} | |
c25393 | lineType(l.line).String()
str = strings.Replace(str, "\x00", " ", -1)
lines[i] = str
}
return lines
} | |
c25394 | {
str += lineType(l.line).String() + "\n"
}
return strings.Replace(str, "\x00", " ", -1)
} | |
c25395 | for _, s := range ei.csiParam {
ret = append(ret, []rune(s)...)
ret = append(ret, ';')
}
return append(ret, ei.curch)
}
return nil
} | |
c25396 |
curFgColor: ColorDefault,
curBgColor: ColorDefault,
mode: mode,
}
return ei
} | |
c25397 |
ei.curBgColor = ColorDefault
ei.csiParam = nil
} | |
c25398 | ei.csiParam[len(ei.csiParam)-1] += string(ch)
return true, nil
case ch == ';':
ei.csiParam = append(ei.csiParam, "")
return true, nil
case ch == 'm':
var err error
switch ei.mode {
case OutputNormal:
err = ei.outputNormal()
case Output256:
err = ei.output256()
}
if err != nil {
... | |
c25399 | termbox.Size()
g.BgColor, g.FgColor = ColorDefault, ColorDefault
g.SelBgColor, g.SelFgColor = ColorDefault, ColorDefault
return g, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.