_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q178300 | Write | test | func (w *fragmentingWriter) Write(b []byte) (int, error) {
if w.err != nil {
return 0, w.err
}
if !w.state.isWritingArgument() {
w.err = errNotWritingArgument
return 0, w.err
}
totalWritten := 0
for {
bytesWritten := w.curChunk.writeAsFits(b)
totalWritten += bytesWritten
if bytesWritten == len(b) {
... | go | {
"resource": ""
} |
q178301 | Flush | test | func (w *fragmentingWriter) Flush() error {
w.curChunk.finish()
w.curFragment.finish(true)
if w.err = w.sender.flushFragment(w.curFragment); w.err != nil {
return w.err
}
if w.curFragment, w.err = w.sender.newFragment(false, w.checksum); w.err != nil {
return w.err
}
w.curChunk = newWritableChunk(w.checksu... | go | {
"resource": ""
} |
q178302 | Close | test | func (w *fragmentingWriter) Close() error {
last := w.state == fragmentingWriteInLastArgument
if w.err != nil {
return w.err
}
if !w.state.isWritingArgument() {
w.err = errNotWritingArgument
return w.err
}
w.curChunk.finish()
// There are three possibilities here:
// 1. There are no more arguments
// ... | go | {
"resource": ""
} |
q178303 | handleCallRes | test | func (c *Connection) handleCallRes(frame *Frame) bool {
if err := c.outbound.forwardPeerFrame(frame); err != nil {
return true
}
return false
} | go | {
"resource": ""
} |
q178304 | Arg2Reader | test | func (response *OutboundCallResponse) Arg2Reader() (ArgReader, error) {
var method []byte
if err := NewArgReader(response.arg1Reader()).Read(&method); err != nil {
return nil, err
}
return response.arg2Reader()
} | go | {
"resource": ""
} |
q178305 | handleError | test | func (c *Connection) handleError(frame *Frame) bool {
errMsg := errorMessage{
id: frame.Header.ID,
}
rbuf := typed.NewReadBuffer(frame.SizedPayload())
if err := errMsg.read(rbuf); err != nil {
c.log.WithFields(
LogField{"remotePeer", c.remotePeerInfo},
ErrField(err),
).Warn("Unable to read error frame."... | go | {
"resource": ""
} |
q178306 | doneReading | test | func (response *OutboundCallResponse) doneReading(unexpected error) {
now := response.timeNow()
isSuccess := unexpected == nil && !response.ApplicationError()
lastAttempt := isSuccess || !response.requestState.HasRetries(unexpected)
// TODO how should this work with retries?
if span := response.span; span != nil... | go | {
"resource": ""
} |
q178307 | newFragment | test | func (w *reqResWriter) newFragment(initial bool, checksum Checksum) (*writableFragment, error) {
if err := w.mex.checkError(); err != nil {
return nil, w.failed(err)
}
message := w.messageForFragment(initial)
// Create the frame
frame := w.conn.opts.FramePool.Get()
frame.Header.ID = w.mex.msgID
frame.Header.... | go | {
"resource": ""
} |
q178308 | flushFragment | test | func (w *reqResWriter) flushFragment(fragment *writableFragment) error {
if w.err != nil {
return w.err
}
frame := fragment.frame.(*Frame)
frame.Header.SetPayloadSize(uint16(fragment.contents.BytesWritten()))
if err := w.mex.checkError(); err != nil {
return w.failed(err)
}
select {
case <-w.mex.ctx.Done(... | go | {
"resource": ""
} |
q178309 | failed | test | func (w *reqResWriter) failed(err error) error {
w.log.Debugf("writer failed: %v existing err: %v", err, w.err)
if w.err != nil {
return w.err
}
w.mex.shutdown()
w.err = err
return w.err
} | go | {
"resource": ""
} |
q178310 | arg1Reader | test | func (r *reqResReader) arg1Reader() (ArgReader, error) {
return r.argReader(false /* last */, reqResReaderPreArg1, reqResReaderPreArg2)
} | go | {
"resource": ""
} |
q178311 | arg2Reader | test | func (r *reqResReader) arg2Reader() (ArgReader, error) {
return r.argReader(false /* last */, reqResReaderPreArg2, reqResReaderPreArg3)
} | go | {
"resource": ""
} |
q178312 | arg3Reader | test | func (r *reqResReader) arg3Reader() (ArgReader, error) {
return r.argReader(true /* last */, reqResReaderPreArg3, reqResReaderComplete)
} | go | {
"resource": ""
} |
q178313 | argReader | test | func (r *reqResReader) argReader(last bool, inState reqResReaderState, outState reqResReaderState) (ArgReader, error) {
if r.state != inState {
return nil, r.failed(errReqResReaderStateMismatch{state: r.state, expectedState: inState})
}
argReader, err := r.contents.ArgReader(last)
if err != nil {
return nil, r... | go | {
"resource": ""
} |
q178314 | recvNextFragment | test | func (r *reqResReader) recvNextFragment(initial bool) (*readableFragment, error) {
if r.initialFragment != nil {
fragment := r.initialFragment
r.initialFragment = nil
r.previousFragment = fragment
return fragment, nil
}
// Wait for the appropriate message from the peer
message := r.messageForFragment(initi... | go | {
"resource": ""
} |
q178315 | releasePreviousFragment | test | func (r *reqResReader) releasePreviousFragment() {
fragment := r.previousFragment
r.previousFragment = nil
if fragment != nil {
fragment.done()
}
} | go | {
"resource": ""
} |
q178316 | failed | test | func (r *reqResReader) failed(err error) error {
r.log.Debugf("reader failed: %v existing err: %v", err, r.err)
if r.err != nil {
return r.err
}
r.mex.shutdown()
r.err = err
return r.err
} | go | {
"resource": ""
} |
q178317 | parseInboundFragment | test | func parseInboundFragment(framePool FramePool, frame *Frame, message message) (*readableFragment, error) {
rbuf := typed.NewReadBuffer(frame.SizedPayload())
fragment := new(readableFragment)
fragment.flags = rbuf.ReadSingleByte()
if err := message.read(rbuf); err != nil {
return nil, err
}
fragment.checksumTyp... | go | {
"resource": ""
} |
q178318 | NewContext | test | func NewContext(timeout time.Duration) (Context, context.CancelFunc) {
ctx, cancel := tchannel.NewContext(timeout)
return Wrap(ctx), cancel
} | go | {
"resource": ""
} |
q178319 | WithHeaders | test | func WithHeaders(ctx context.Context, headers map[string]string) Context {
return tchannel.WrapWithHeaders(ctx, headers)
} | go | {
"resource": ""
} |
q178320 | healthCheck | test | func (c *Connection) healthCheck(connID uint32) {
defer close(c.healthCheckDone)
opts := c.opts.HealthChecks
ticker := c.timeTicker(opts.Interval)
defer ticker.Stop()
consecutiveFailures := 0
for {
select {
case <-ticker.C:
case <-c.healthCheckCtx.Done():
return
}
ctx, cancel := context.WithTimeo... | go | {
"resource": ""
} |
q178321 | SetTimeout | test | func (cb *ContextBuilder) SetTimeout(timeout time.Duration) *ContextBuilder {
cb.Timeout = timeout
return cb
} | go | {
"resource": ""
} |
q178322 | AddHeader | test | func (cb *ContextBuilder) AddHeader(key, value string) *ContextBuilder {
if cb.Headers == nil {
cb.Headers = map[string]string{key: value}
} else {
cb.Headers[key] = value
}
return cb
} | go | {
"resource": ""
} |
q178323 | SetHeaders | test | func (cb *ContextBuilder) SetHeaders(headers map[string]string) *ContextBuilder {
cb.Headers = headers
cb.replaceParentHeaders = true
return cb
} | go | {
"resource": ""
} |
q178324 | SetConnectTimeout | test | func (cb *ContextBuilder) SetConnectTimeout(d time.Duration) *ContextBuilder {
cb.ConnectTimeout = d
return cb
} | go | {
"resource": ""
} |
q178325 | SetRetryOptions | test | func (cb *ContextBuilder) SetRetryOptions(retryOptions *RetryOptions) *ContextBuilder {
cb.RetryOptions = retryOptions
return cb
} | go | {
"resource": ""
} |
q178326 | SetTimeoutPerAttempt | test | func (cb *ContextBuilder) SetTimeoutPerAttempt(timeoutPerAttempt time.Duration) *ContextBuilder {
if cb.RetryOptions == nil {
cb.RetryOptions = &RetryOptions{}
}
cb.RetryOptions.TimeoutPerAttempt = timeoutPerAttempt
return cb
} | go | {
"resource": ""
} |
q178327 | SetParentContext | test | func (cb *ContextBuilder) SetParentContext(ctx context.Context) *ContextBuilder {
cb.ParentContext = ctx
return cb
} | go | {
"resource": ""
} |
q178328 | Build | test | func (cb *ContextBuilder) Build() (ContextWithHeaders, context.CancelFunc) {
params := &tchannelCtxParams{
options: cb.CallOptions,
call: cb.incomingCall,
retryOptions: cb.RetryOptions,
connectTimeout: cb.ConnectTimeout,
hideListeningOnOutbound: cb.hideL... | go | {
"resource": ""
} |
q178329 | overrideHeaders | test | func (c *CallOptions) overrideHeaders(headers transportHeaders) {
if c.Format != "" {
headers[ArgScheme] = c.Format.String()
}
if c.ShardKey != "" {
headers[ShardKey] = c.ShardKey
}
if c.RoutingKey != "" {
headers[RoutingKey] = c.RoutingKey
}
if c.RoutingDelegate != "" {
headers[RoutingDelegate] = c.Rout... | go | {
"resource": ""
} |
q178330 | Read | test | func (r ArgReadHelper) Read(bs *[]byte) error {
return r.read(func() error {
var err error
*bs, err = ioutil.ReadAll(r.reader)
return err
})
} | go | {
"resource": ""
} |
q178331 | ReadJSON | test | func (r ArgReadHelper) ReadJSON(data interface{}) error {
return r.read(func() error {
// TChannel allows for 0 length values (not valid JSON), so we use a bufio.Reader
// to check whether data is of 0 length.
reader := bufio.NewReader(r.reader)
if _, err := reader.Peek(1); err == io.EOF {
// If the data is... | go | {
"resource": ""
} |
q178332 | NewArgWriter | test | func NewArgWriter(writer io.WriteCloser, err error) ArgWriteHelper {
return ArgWriteHelper{writer, err}
} | go | {
"resource": ""
} |
q178333 | Write | test | func (w ArgWriteHelper) Write(bs []byte) error {
return w.write(func() error {
_, err := w.writer.Write(bs)
return err
})
} | go | {
"resource": ""
} |
q178334 | WriteJSON | test | func (w ArgWriteHelper) WriteJSON(data interface{}) error {
return w.write(func() error {
e := json.NewEncoder(w.writer)
return e.Encode(data)
})
} | go | {
"resource": ""
} |
q178335 | Register | test | func Register(registrar tchannel.Registrar) {
handler := func(ctx context.Context, call *tchannel.InboundCall) {
req, err := thttp.ReadRequest(call)
if err != nil {
registrar.Logger().WithFields(
tchannel.LogField{Key: "err", Value: err.Error()},
).Warn("Failed to read HTTP request.")
return
}
se... | go | {
"resource": ""
} |
q178336 | Count | test | func (r *relayItems) Count() int {
r.RLock()
n := len(r.items) - int(r.tombs)
r.RUnlock()
return n
} | go | {
"resource": ""
} |
q178337 | Get | test | func (r *relayItems) Get(id uint32) (relayItem, bool) {
r.RLock()
item, ok := r.items[id]
r.RUnlock()
return item, ok
} | go | {
"resource": ""
} |
q178338 | Add | test | func (r *relayItems) Add(id uint32, item relayItem) {
r.Lock()
r.items[id] = item
r.Unlock()
} | go | {
"resource": ""
} |
q178339 | Entomb | test | func (r *relayItems) Entomb(id uint32, deleteAfter time.Duration) (relayItem, bool) {
r.Lock()
if r.tombs > _maxRelayTombs {
r.Unlock()
r.logger.WithFields(LogField{"id", id}).Warn("Too many tombstones, deleting relay item immediately.")
return r.Delete(id)
}
item, ok := r.items[id]
if !ok {
r.Unlock()
r... | go | {
"resource": ""
} |
q178340 | NewRelayer | test | func NewRelayer(ch *Channel, conn *Connection) *Relayer {
r := &Relayer{
relayHost: ch.RelayHost(),
maxTimeout: ch.relayMaxTimeout,
localHandler: ch.relayLocal,
outbound: newRelayItems(conn.log.WithFields(LogField{"relayItems", "outbound"})),
inbound: newRelayItems(conn.log.WithFields(LogField{... | go | {
"resource": ""
} |
q178341 | Relay | test | func (r *Relayer) Relay(f *Frame) error {
if f.messageType() != messageTypeCallReq {
err := r.handleNonCallReq(f)
if err == errUnknownID {
// This ID may be owned by an outgoing call, so check the outbound
// message exchange, and if it succeeds, then the frame has been
// handled successfully.
if err ... | go | {
"resource": ""
} |
q178342 | Receive | test | func (r *Relayer) Receive(f *Frame, fType frameType) (sent bool, failureReason string) {
id := f.Header.ID
// If we receive a response frame, we expect to find that ID in our outbound.
// If we receive a request frame, we expect to find that ID in our inbound.
items := r.receiverItems(fType)
item, ok := items.Ge... | go | {
"resource": ""
} |
q178343 | handleNonCallReq | test | func (r *Relayer) handleNonCallReq(f *Frame) error {
frameType := frameTypeFor(f)
finished := finishesCall(f)
// If we read a request frame, we need to use the outbound map to decide
// the destination. Otherwise, we use the inbound map.
items := r.outbound
if frameType == responseFrame {
items = r.inbound
}
... | go | {
"resource": ""
} |
q178344 | addRelayItem | test | func (r *Relayer) addRelayItem(isOriginator bool, id, remapID uint32, destination *Relayer, ttl time.Duration, span Span, call RelayCall) relayItem {
item := relayItem{
call: call,
remapID: remapID,
destination: destination,
span: span,
}
items := r.inbound
if isOriginator {
items = r.o... | go | {
"resource": ""
} |
q178345 | failRelayItem | test | func (r *Relayer) failRelayItem(items *relayItems, id uint32, failure string) {
item, ok := items.Get(id)
if !ok {
items.logger.WithFields(LogField{"id", id}).Warn("Attempted to fail non-existent relay item.")
return
}
// The call could time-out right as we entomb it, which would cause spurious
// error logs,... | go | {
"resource": ""
} |
q178346 | WriteStruct | test | func WriteStruct(writer io.Writer, s thrift.TStruct) error {
wp := getProtocolWriter(writer)
err := s.Write(wp.protocol)
thriftProtocolPool.Put(wp)
return err
} | go | {
"resource": ""
} |
q178347 | ReadStruct | test | func ReadStruct(reader io.Reader, s thrift.TStruct) error {
wp := getProtocolReader(reader)
err := s.Read(wp.protocol)
thriftProtocolPool.Put(wp)
return err
} | go | {
"resource": ""
} |
q178348 | EnsureEmpty | test | func EnsureEmpty(r io.Reader, stage string) error {
buf := _bufPool.Get().(*[]byte)
defer _bufPool.Put(buf)
n, err := r.Read(*buf)
if n > 0 {
return fmt.Errorf("found unexpected bytes after %s, found (upto 128 bytes): %x", stage, (*buf)[:n])
}
if err == io.EOF {
return nil
}
return err
} | go | {
"resource": ""
} |
q178349 | NewServer | test | func NewServer(optFns ...Option) Server {
opts := getOptions(optFns)
if opts.external {
return newExternalServer(opts)
}
ch, err := tchannel.NewChannel(opts.svcName, &tchannel.ChannelOptions{
Logger: tchannel.NewLevelLogger(tchannel.NewLogger(os.Stderr), tchannel.LogLevelWarn),
})
if err != nil {
panic("fa... | go | {
"resource": ""
} |
q178350 | Advertise | test | func (s *internalServer) Advertise(hyperbahnHosts []string) error {
config := hyperbahn.Configuration{InitialNodes: hyperbahnHosts}
hc, err := hyperbahn.NewClient(s.ch, config, nil)
if err != nil {
panic("failed to setup Hyperbahn client: " + err.Error())
}
return hc.Advertise()
} | go | {
"resource": ""
} |
q178351 | handleCallReqContinue | test | func (c *Connection) handleCallReqContinue(frame *Frame) bool {
if err := c.inbound.forwardPeerFrame(frame); err != nil {
// If forward fails, it's due to a timeout. We can free this frame.
return true
}
return false
} | go | {
"resource": ""
} |
q178352 | dispatchInbound | test | func (c *Connection) dispatchInbound(_ uint32, _ uint32, call *InboundCall, frame *Frame) {
if call.log.Enabled(LogLevelDebug) {
call.log.Debugf("Received incoming call for %s from %s", call.ServiceName(), c.remotePeerInfo)
}
if err := call.readMethod(); err != nil {
call.log.WithFields(
LogField{"remotePeer... | go | {
"resource": ""
} |
q178353 | CallOptions | test | func (call *InboundCall) CallOptions() *CallOptions {
return &CallOptions{
callerName: call.CallerName(),
Format: call.Format(),
ShardKey: call.ShardKey(),
RoutingDelegate: call.RoutingDelegate(),
RoutingKey: call.RoutingKey(),
}
} | go | {
"resource": ""
} |
q178354 | Response | test | func (call *InboundCall) Response() *InboundCallResponse {
if call.err != nil {
// While reading Thrift, we cannot distinguish between malformed Thrift and other errors,
// and so we may try to respond with a bad request. We should ensure that the response
// is marked as failed if the request has failed so that... | go | {
"resource": ""
} |
q178355 | SendSystemError | test | func (response *InboundCallResponse) SendSystemError(err error) error {
if response.err != nil {
return response.err
}
// Fail all future attempts to read fragments
response.state = reqResWriterComplete
response.systemError = true
response.doneSending()
response.call.releasePreviousFragment()
span := Current... | go | {
"resource": ""
} |
q178356 | SetApplicationError | test | func (response *InboundCallResponse) SetApplicationError() error {
if response.state > reqResWriterPreArg2 {
return response.failed(errReqResWriterStateMismatch{
state: response.state,
expectedState: reqResWriterPreArg2,
})
}
response.applicationError = true
return nil
} | go | {
"resource": ""
} |
q178357 | Arg2Writer | test | func (response *InboundCallResponse) Arg2Writer() (ArgWriter, error) {
if err := NewArgWriter(response.arg1Writer()).Write(nil); err != nil {
return nil, err
}
return response.arg2Writer()
} | go | {
"resource": ""
} |
q178358 | doneSending | test | func (response *InboundCallResponse) doneSending() {
// TODO(prashant): Move this to when the message is actually being sent.
now := response.timeNow()
if span := response.span; span != nil {
if response.applicationError || response.systemError {
ext.Error.Set(span, true)
}
span.FinishWithOptions(opentraci... | go | {
"resource": ""
} |
q178359 | newState | test | func newState(v *parser.Thrift, all map[string]parseState) *State {
typedefs := make(map[string]*parser.Type)
for k, v := range v.Typedefs {
typedefs[k] = v.Type
}
// Enums are typedefs to an int64.
i64Type := &parser.Type{Name: "i64"}
for k := range v.Enums {
typedefs[k] = i64Type
}
return &State{typedef... | go | {
"resource": ""
} |
q178360 | rootType | test | func (s *State) rootType(thriftType *parser.Type) *parser.Type {
if state, newType, include := s.checkInclude(thriftType); include != nil {
return state.rootType(newType)
}
if v, ok := s.typedefs[thriftType.Name]; ok {
return s.rootType(v)
}
return thriftType
} | go | {
"resource": ""
} |
q178361 | checkInclude | test | func (s *State) checkInclude(thriftType *parser.Type) (*State, *parser.Type, *Include) {
parts := strings.SplitN(thriftType.Name, ".", 2)
if len(parts) < 2 {
return nil, nil, nil
}
newType := *thriftType
newType.Name = parts[1]
include := s.includes[parts[0]]
state := s.all[include.file]
return state.global... | go | {
"resource": ""
} |
q178362 | isResultPointer | test | func (s *State) isResultPointer(thriftType *parser.Type) bool {
_, basicGoType := thriftToGo[s.rootType(thriftType).Name]
return !basicGoType
} | go | {
"resource": ""
} |
q178363 | goType | test | func (s *State) goType(thriftType *parser.Type) string {
return s.goTypePrefix("", thriftType)
} | go | {
"resource": ""
} |
q178364 | goTypePrefix | test | func (s *State) goTypePrefix(prefix string, thriftType *parser.Type) string {
switch thriftType.Name {
case "binary":
return "[]byte"
case "list":
return "[]" + s.goType(thriftType.ValueType)
case "set":
return "map[" + s.goType(thriftType.ValueType) + "]bool"
case "map":
return "map[" + s.goType(thriftTyp... | go | {
"resource": ""
} |
q178365 | NewContext | test | func NewContext(timeout time.Duration) (context.Context, context.CancelFunc) {
return NewContextBuilder(timeout).Build()
} | go | {
"resource": ""
} |
q178366 | newIncomingContext | test | func newIncomingContext(call IncomingCall, timeout time.Duration) (context.Context, context.CancelFunc) {
return NewContextBuilder(timeout).
setIncomingCall(call).
Build()
} | go | {
"resource": ""
} |
q178367 | CurrentCall | test | func CurrentCall(ctx context.Context) IncomingCall {
if params := getTChannelParams(ctx); params != nil {
return params.call
}
return nil
} | go | {
"resource": ""
} |
q178368 | New | test | func New(seed int64) *rand.Rand {
return rand.New(&lockedSource{src: rand.NewSource(seed)})
} | go | {
"resource": ""
} |
q178369 | Health | test | func (h *metaHandler) Health(ctx Context, req *meta.HealthRequest) (*meta.HealthStatus, error) {
ok, message := h.healthFn(ctx, metaReqToReq(req))
if message == "" {
return &meta.HealthStatus{Ok: ok}, nil
}
return &meta.HealthStatus{Ok: ok, Message: &message}, nil
} | go | {
"resource": ""
} |
q178370 | Headers | test | func (c headerCtx) Headers() map[string]string {
if h := c.headers(); h != nil {
return h.reqHeaders
}
return nil
} | go | {
"resource": ""
} |
q178371 | ResponseHeaders | test | func (c headerCtx) ResponseHeaders() map[string]string {
if h := c.headers(); h != nil {
return h.respHeaders
}
return nil
} | go | {
"resource": ""
} |
q178372 | SetResponseHeaders | test | func (c headerCtx) SetResponseHeaders(headers map[string]string) {
if h := c.headers(); h != nil {
h.respHeaders = headers
return
}
panic("SetResponseHeaders called on ContextWithHeaders not created via WrapWithHeaders")
} | go | {
"resource": ""
} |
q178373 | Child | test | func (c headerCtx) Child() ContextWithHeaders {
var headersCopy headersContainer
if h := c.headers(); h != nil {
headersCopy = *h
}
return Wrap(context.WithValue(c.Context, contextKeyHeaders, &headersCopy))
} | go | {
"resource": ""
} |
q178374 | Wrap | test | func Wrap(ctx context.Context) ContextWithHeaders {
hctx := headerCtx{Context: ctx}
if h := hctx.headers(); h != nil {
return hctx
}
// If there is no header container, we should create an empty one.
return WrapWithHeaders(ctx, nil)
} | go | {
"resource": ""
} |
q178375 | WrapWithHeaders | test | func WrapWithHeaders(ctx context.Context, headers map[string]string) ContextWithHeaders {
h := &headersContainer{
reqHeaders: headers,
}
newCtx := context.WithValue(ctx, contextKeyHeaders, h)
return headerCtx{Context: newCtx}
} | go | {
"resource": ""
} |
q178376 | WithoutHeaders | test | func WithoutHeaders(ctx context.Context) context.Context {
return context.WithValue(context.WithValue(ctx, contextKeyTChannel, nil), contextKeyHeaders, nil)
} | go | {
"resource": ""
} |
q178377 | Notify | test | func (e *errNotifier) Notify(err error) error {
// The code should never try to Notify(nil).
if err == nil {
panic("cannot Notify with no error")
}
// There may be some sort of race where we try to notify the mex twice.
if !e.notified.CAS(false, true) {
return fmt.Errorf("cannot broadcast error: %v, already h... | go | {
"resource": ""
} |
q178378 | forwardPeerFrame | test | func (mex *messageExchange) forwardPeerFrame(frame *Frame) error {
// We want a very specific priority here:
// 1. Timeouts/cancellation (mex.ctx errors)
// 2. Whether recvCh has buffer space (non-blocking select over mex.recvCh)
// 3. Other mex errors (mex.errCh)
// Which is why we check the context error only (i... | go | {
"resource": ""
} |
q178379 | recvPeerFrame | test | func (mex *messageExchange) recvPeerFrame() (*Frame, error) {
// We have to check frames/errors in a very specific order here:
// 1. Timeouts/cancellation (mex.ctx errors)
// 2. Any pending frames (non-blocking select over mex.recvCh)
// 3. Other mex errors (mex.errCh)
// Which is why we check the context error on... | go | {
"resource": ""
} |
q178380 | recvPeerFrameOfType | test | func (mex *messageExchange) recvPeerFrameOfType(msgType messageType) (*Frame, error) {
frame, err := mex.recvPeerFrame()
if err != nil {
return nil, err
}
switch frame.Header.messageType {
case msgType:
return frame, nil
case messageTypeError:
// If we read an error frame, we can release it once we deseri... | go | {
"resource": ""
} |
q178381 | shutdown | test | func (mex *messageExchange) shutdown() {
// The reader and writer side can both hit errors and try to shutdown the mex,
// so we ensure that it's only shut down once.
if !mex.shutdownAtomic.CAS(false, true) {
return
}
if mex.errChNotified.CAS(false, true) {
mex.errCh.Notify(errMexShutdown)
}
mex.mexset.rem... | go | {
"resource": ""
} |
q178382 | newMessageExchangeSet | test | func newMessageExchangeSet(log Logger, name string) *messageExchangeSet {
return &messageExchangeSet{
name: name,
log: log.WithFields(LogField{"exchange", name}),
exchanges: make(map[uint32]*messageExchange),
expiredExchanges: make(map[uint32]struct{}),
}
} | go | {
"resource": ""
} |
q178383 | addExchange | test | func (mexset *messageExchangeSet) addExchange(mex *messageExchange) error {
if mexset.shutdown {
return errMexSetShutdown
}
if _, ok := mexset.exchanges[mex.msgID]; ok {
return errDuplicateMex
}
mexset.exchanges[mex.msgID] = mex
return nil
} | go | {
"resource": ""
} |
q178384 | newExchange | test | func (mexset *messageExchangeSet) newExchange(ctx context.Context, framePool FramePool,
msgType messageType, msgID uint32, bufferSize int) (*messageExchange, error) {
if mexset.log.Enabled(LogLevelDebug) {
mexset.log.Debugf("Creating new %s message exchange for [%v:%d]", mexset.name, msgType, msgID)
}
mex := &me... | go | {
"resource": ""
} |
q178385 | deleteExchange | test | func (mexset *messageExchangeSet) deleteExchange(msgID uint32) (found, timedOut bool) {
if _, found := mexset.exchanges[msgID]; found {
delete(mexset.exchanges, msgID)
return true, false
}
if _, expired := mexset.expiredExchanges[msgID]; expired {
delete(mexset.expiredExchanges, msgID)
return false, true
}... | go | {
"resource": ""
} |
q178386 | removeExchange | test | func (mexset *messageExchangeSet) removeExchange(msgID uint32) {
if mexset.log.Enabled(LogLevelDebug) {
mexset.log.Debugf("Removing %s message exchange %d", mexset.name, msgID)
}
mexset.Lock()
found, expired := mexset.deleteExchange(msgID)
mexset.Unlock()
if !found && !expired {
mexset.log.WithFields(
Lo... | go | {
"resource": ""
} |
q178387 | expireExchange | test | func (mexset *messageExchangeSet) expireExchange(msgID uint32) {
mexset.log.Debugf(
"Removing %s message exchange %d due to timeout, cancellation or blackhole",
mexset.name,
msgID,
)
mexset.Lock()
// TODO(aniketp): explore if cancel can be called everytime we expire an exchange
found, expired := mexset.dele... | go | {
"resource": ""
} |
q178388 | forwardPeerFrame | test | func (mexset *messageExchangeSet) forwardPeerFrame(frame *Frame) error {
if mexset.log.Enabled(LogLevelDebug) {
mexset.log.Debugf("forwarding %s %s", mexset.name, frame.Header)
}
mexset.RLock()
mex := mexset.exchanges[frame.Header.ID]
mexset.RUnlock()
if mex == nil {
// This is ok since the exchange might h... | go | {
"resource": ""
} |
q178389 | copyExchanges | test | func (mexset *messageExchangeSet) copyExchanges() (shutdown bool, exchanges map[uint32]*messageExchange) {
if mexset.shutdown {
return true, nil
}
exchangesCopy := make(map[uint32]*messageExchange, len(mexset.exchanges))
for k, mex := range mexset.exchanges {
exchangesCopy[k] = mex
}
return false, exchanges... | go | {
"resource": ""
} |
q178390 | stopExchanges | test | func (mexset *messageExchangeSet) stopExchanges(err error) {
if mexset.log.Enabled(LogLevelDebug) {
mexset.log.Debugf("stopping %v exchanges due to error: %v", mexset.count(), err)
}
mexset.Lock()
shutdown, exchanges := mexset.copyExchanges()
mexset.shutdown = true
mexset.Unlock()
if shutdown {
mexset.log.... | go | {
"resource": ""
} |
q178391 | NewFrame | test | func NewFrame(payloadCapacity int) *Frame {
f := &Frame{}
f.buffer = make([]byte, payloadCapacity+FrameHeaderSize)
f.Payload = f.buffer[FrameHeaderSize:]
f.headerBuffer = f.buffer[:FrameHeaderSize]
return f
} | go | {
"resource": ""
} |
q178392 | ReadBody | test | func (f *Frame) ReadBody(header []byte, r io.Reader) error {
// Copy the header into the underlying buffer so we have an assembled frame
// that can be directly forwarded.
copy(f.buffer, header)
// Parse the header into our typed struct.
if err := f.Header.read(typed.NewReadBuffer(header)); err != nil {
return ... | go | {
"resource": ""
} |
q178393 | WriteOut | test | func (f *Frame) WriteOut(w io.Writer) error {
var wbuf typed.WriteBuffer
wbuf.Wrap(f.headerBuffer)
if err := f.Header.write(&wbuf); err != nil {
return err
}
fullFrame := f.buffer[:f.Header.FrameSize()]
if _, err := w.Write(fullFrame); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q178394 | CanRetry | test | func (r RetryOn) CanRetry(err error) bool {
if r == RetryNever {
return false
}
if r == RetryDefault {
r = RetryConnectionError
}
code := getErrCode(err)
if code == ErrCodeBusy || code == ErrCodeDeclined {
return true
}
// Never retry bad requests, since it will probably cause another bad request.
if c... | go | {
"resource": ""
} |
q178395 | HasRetries | test | func (rs *RequestState) HasRetries(err error) bool {
if rs == nil {
return false
}
rOpts := rs.retryOpts
return rs.Attempt < rOpts.MaxAttempts && rOpts.RetryOn.CanRetry(err)
} | go | {
"resource": ""
} |
q178396 | SinceStart | test | func (rs *RequestState) SinceStart(now time.Time, fallback time.Duration) time.Duration {
if rs == nil {
return fallback
}
return now.Sub(rs.Start)
} | go | {
"resource": ""
} |
q178397 | AddSelectedPeer | test | func (rs *RequestState) AddSelectedPeer(hostPort string) {
if rs == nil {
return
}
host := getHost(hostPort)
if rs.SelectedPeers == nil {
rs.SelectedPeers = map[string]struct{}{
hostPort: {},
host: {},
}
} else {
rs.SelectedPeers[hostPort] = struct{}{}
rs.SelectedPeers[host] = struct{}{}
}
} | go | {
"resource": ""
} |
q178398 | RunWithRetry | test | func (ch *Channel) RunWithRetry(runCtx context.Context, f RetriableFunc) error {
var err error
opts := getRetryOptions(runCtx)
rs := ch.getRequestState(opts)
defer requestStatePool.Put(rs)
for i := 0; i < opts.MaxAttempts; i++ {
rs.Attempt++
if opts.TimeoutPerAttempt == 0 {
err = f(runCtx, rs)
} else {... | go | {
"resource": ""
} |
q178399 | ChecksumSize | test | func (t ChecksumType) ChecksumSize() int {
switch t {
case ChecksumTypeNone:
return 0
case ChecksumTypeCrc32, ChecksumTypeCrc32C:
return crc32.Size
case ChecksumTypeFarmhash:
return 4
default:
return 0
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.