id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c178300 | was more data than fit into the fragment, so flush the current fragment,
// start a new fragment and chunk, and continue writing
if w.err = w.Flush(); w.err != nil {
return totalWritten, w.err
}
b = b[bytesWritten:]
}
} | |
c178301 | != nil {
return w.err
}
w.curChunk = newWritableChunk(w.checksum, w.curFragment.contents)
return nil
} | |
c178302 |
// There's enough room in this fragment for the next argument's
// initial chunk, so we're done here
return nil
}
// This fragment is full - flush and prepare for another argument
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
}
// Write an empty chunk to indicate this argument has ended
w.curFragment.contents.WriteUint16(0)
return nil
} | |
c178303 | err := c.outbound.forwardPeerFrame(frame); err != nil {
return true
}
return false
} | |
c178304 | NewArgReader(response.arg1Reader()).Read(&method); err != nil {
return nil, err
}
return response.arg2Reader()
} | |
c178305 | nil {
c.log.WithFields(
LogField{"frameHeader", frame.Header.String()},
LogField{"id", errMsg.id},
LogField{"errorMessage", errMsg.message},
LogField{"errorCode", errMsg.errCode},
ErrField(err),
).Info("Failed to forward error frame.")
return true
}
// If the frame was forwarded, then the other side is responsible for releasing the frame.
return false
} | |
c178306 | if unexpected != nil {
// TODO(prashant): Report the error code type as per metrics doc and enable.
// response.statsReporter.IncCounter("outbound.calls.system-errors", response.commonStatsTags, 1)
} else if response.ApplicationError() {
// TODO(prashant): Figure out how to add "type" to tags, which TChannel does not know about.
response.statsReporter.IncCounter("outbound.calls.per-attempt.app-errors", response.commonStatsTags, 1)
if lastAttempt {
response.statsReporter.IncCounter("outbound.calls.app-errors", response.commonStatsTags, 1)
}
} else {
response.statsReporter.IncCounter("outbound.calls.success", response.commonStatsTags, 1)
}
response.mex.shutdown()
} | |
c178307 | // Write the message into the fragment, reserving flags and checksum bytes
wbuf := typed.NewWriteBuffer(frame.Payload[:])
fragment := new(writableFragment)
fragment.frame = frame
fragment.flagsRef = wbuf.DeferByte()
if err := message.write(wbuf); err != nil {
return nil, err
}
wbuf.WriteSingleByte(byte(checksum.TypeCode()))
fragment.checksumRef = wbuf.DeferBytes(checksum.Size())
fragment.checksum = checksum
fragment.contents = wbuf
return fragment, wbuf.Err()
} | |
c178308 | {
case <-w.mex.ctx.Done():
return w.failed(GetContextError(w.mex.ctx.Err()))
case <-w.mex.errCh.c:
return w.failed(w.mex.errCh.err)
case w.conn.sendCh <- frame:
return nil
}
} | |
c178309 | != nil {
return w.err
}
w.mex.shutdown()
w.err = err
return w.err
} | |
c178310 | last */, reqResReaderPreArg1, reqResReaderPreArg2)
} | |
c178311 | last */, reqResReaderPreArg2, reqResReaderPreArg3)
} | |
c178312 | last */, reqResReaderPreArg3, reqResReaderComplete)
} | |
c178313 | argReader, err := r.contents.ArgReader(last)
if err != nil {
return nil, r.failed(err)
}
r.state = outState
return argReader, nil
} | |
c178314 | // the normal doneReading path so stats get updated with this error.
r.err = err.AsSystemError()
return nil, err
}
return nil, r.failed(err)
}
// Parse the message and setup the fragment
fragment, err := parseInboundFragment(r.mex.framePool, frame, message)
if err != nil {
return nil, r.failed(err)
}
r.previousFragment = fragment
return fragment, nil
} | |
c178315 | nil
if fragment != nil {
fragment.done()
}
} | |
c178316 | != nil {
return r.err
}
r.mex.shutdown()
r.err = err
return r.err
} | |
c178317 | fragment.checksumType = ChecksumType(rbuf.ReadSingleByte())
fragment.checksum = rbuf.ReadBytes(fragment.checksumType.ChecksumSize())
fragment.contents = rbuf
fragment.onDone = func() {
framePool.Release(frame)
}
return fragment, rbuf.Err()
} | |
c178318 | := tchannel.NewContext(timeout)
return Wrap(ctx), cancel
} | |
c178319 | tchannel.WrapWithHeaders(ctx, headers)
} | |
c178320 | }
consecutiveFailures = 0
continue
}
// If the health check failed because the connection closed or health
// checks were stopped, we don't need to log or close the connection.
if GetSystemErrorCode(err) == ErrCodeCancelled || err == ErrInvalidConnectionState {
c.log.WithFields(ErrField(err)).Debug("Health checker stopped.")
return
}
consecutiveFailures++
c.log.WithFields(LogFields{
{"consecutiveFailures", consecutiveFailures},
ErrField(err),
{"failuresToClose", opts.FailuresToClose},
}...).Warn("Failed active health check.")
if consecutiveFailures >= opts.FailuresToClose {
c.close(LogFields{
{"reason", "health check failure"},
ErrField(err),
}...)
return
}
}
} | |
c178321 | cb.Timeout = timeout
return cb
} | |
c178322 | == nil {
cb.Headers = map[string]string{key: value}
} else {
cb.Headers[key] = value
}
return cb
} | |
c178323 | = headers
cb.replaceParentHeaders = true
return cb
} | |
c178324 | cb.ConnectTimeout = d
return cb
} | |
c178325 | cb.RetryOptions = retryOptions
return cb
} | |
c178326 | cb.RetryOptions = &RetryOptions{}
}
cb.RetryOptions.TimeoutPerAttempt = timeoutPerAttempt
return cb
} | |
c178327 | *ContextBuilder {
cb.ParentContext = ctx
return cb
} | |
c178328 | headerCtx, ok := parent.(headerCtx); ok {
// Unwrap any headerCtx, since we'll be rewrapping anyway.
parent = headerCtx.Context
}
var (
ctx context.Context
cancel context.CancelFunc
)
// All contexts created must have a timeout, but if the parent
// already has a timeout, and the user has not specified one, then we
// can use context.WithCancel
_, parentHasDeadline := parent.Deadline()
if cb.Timeout == 0 && parentHasDeadline {
ctx, cancel = context.WithCancel(parent)
} else {
ctx, cancel = context.WithTimeout(parent, cb.Timeout)
}
ctx = context.WithValue(ctx, contextKeyTChannel, params)
return WrapWithHeaders(ctx, cb.getHeaders()), cancel
} | |
c178329 | if c.RoutingDelegate != "" {
headers[RoutingDelegate] = c.RoutingDelegate
}
if c.callerName != "" {
headers[CallerName] = c.callerName
}
} | |
c178330 | *bs, err = ioutil.ReadAll(r.reader)
return err
})
} | |
c178331 | 0 length.
reader := bufio.NewReader(r.reader)
if _, err := reader.Peek(1); err == io.EOF {
// If the data is 0 length, then we don't try to read anything.
return nil
} else if err != nil {
return err
}
d := json.NewDecoder(reader)
return d.Decode(data)
})
} | |
c178332 | return ArgWriteHelper{writer, err}
} | |
c178333 | w.write(func() error {
_, err := w.writer.Write(bs)
return err
})
} | |
c178334 | w.write(func() error {
e := json.NewEncoder(w.writer)
return e.Encode(data)
})
} | |
c178335 | read HTTP request.")
return
}
serveHTTP(req, call.Response())
}
registrar.Register(tchannel.HandlerFunc(handler), "_pprof")
} | |
c178336 | - int(r.tombs)
r.RUnlock()
return n
} | |
c178337 | {
r.RLock()
item, ok := r.items[id]
r.RUnlock()
return item, ok
} | |
c178338 |
r.items[id] = item
r.Unlock()
} | |
c178339 | relay item to entomb.")
return item, false
}
if item.tomb {
r.Unlock()
r.logger.WithFields(LogField{"id", id}).Warn("Re-entombing a tombstone.")
return item, false
}
r.tombs++
item.tomb = true
r.items[id] = item
r.Unlock()
// TODO: We should be clearing these out in batches, rather than creating
// individual timers for each item.
time.AfterFunc(deleteAfter, func() { r.Delete(id) })
return item, true
} | |
c178340 | conn.conn.RemoteAddr().String(),
RemoteProcessName: conn.RemotePeerInfo().ProcessName,
IsOutbound: conn.connDirection == outbound,
},
logger: conn.log,
}
r.timeouts = newRelayTimerPool(r.timeoutRelayItem, ch.relayTimerVerify)
return r
} | |
c178341 | check the outbound
// message exchange, and if it succeeds, then the frame has been
// handled successfully.
if err := r.conn.outbound.forwardPeerFrame(f); err == nil {
return nil
}
}
return err
}
return r.handleCallReq(newLazyCallReq(f))
} | |
c178342 |
} else if len(failMsg) > 0 {
item.call.Failed(failMsg)
}
}
select {
case r.conn.sendCh <- f:
default:
// Buffer is full, so drop this frame and cancel the call.
r.logger.WithFields(
LogField{"id", id},
).Warn("Dropping call due to slow connection.")
items := r.receiverItems(fType)
err := _relayErrorDestConnSlow
// If we're dealing with a response frame, then the client is slow.
if fType == responseFrame {
err = _relayErrorSourceConnSlow
}
r.failRelayItem(items, id, err)
return false, err
}
if finished {
r.finishRelayItem(items, id)
}
return true, ""
} | |
c178343 | TODO: metrics for late-arriving frames.
return nil
}
originalID := f.Header.ID
f.Header.ID = item.remapID
sent, failure := item.destination.Receive(f, frameType)
if !sent {
r.failRelayItem(items, originalID, failure)
return nil
}
if finished {
r.finishRelayItem(items, originalID)
}
return nil
} | |
c178344 |
if isOriginator {
items = r.outbound
}
item.timeout = r.timeouts.Get()
items.Add(id, item)
item.timeout.Start(ttl, items, id, isOriginator)
return item
} | |
c178345 | = items.Entomb(id, _relayTombTTL)
if !ok {
return
}
if item.call != nil {
// If the client is too slow, then there's no point sending an error frame.
if failure != _relayErrorSourceConnSlow {
r.conn.SendSystemError(id, item.span, errFrameNotSent)
}
item.call.Failed(failure)
item.call.End()
}
r.decrementPending()
} | |
c178346 | s.Write(wp.protocol)
thriftProtocolPool.Put(wp)
return err
} | |
c178347 | s.Read(wp.protocol)
thriftProtocolPool.Put(wp)
return err
} | |
c178348 |
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
} | |
c178349 | opts: opts,
}
tServer := thrift.NewServer(ch)
tServer.Register(gen.NewTChanSecondServiceServer(handler{calls: &s.thriftCalls}))
ch.Register(raw.Wrap(rawHandler{calls: &s.rawCalls}), "echo")
if len(opts.advertiseHosts) > 0 {
if err := s.Advertise(opts.advertiseHosts); err != nil {
panic("failed to advertise: " + err.Error())
}
}
return s
} | |
c178350 |
hc, err := hyperbahn.NewClient(s.ch, config, nil)
if err != nil {
panic("failed to setup Hyperbahn client: " + err.Error())
}
return hc.Advertise()
} | |
c178351 | fails, it's due to a timeout. We can free this frame.
return true
}
return false
} | |
c178352 | if call.mex.ctx.Err() != nil {
call.mex.inboundExpired()
}
case <-call.mex.errCh.c:
if c.log.Enabled(LogLevelDebug) {
call.log.Debugf("Wait for timeout/cancellation interrupted by error: %v", call.mex.errCh.err)
}
// when an exchange errors out, mark the exchange as expired
// and call cancel so the server handler's context is canceled
// TODO: move the cancel to the parent context at connnection level
call.response.cancel()
call.mex.inboundExpired()
}
}()
c.handler.Handle(call.mex.ctx, call)
} | |
c178353 | call.ShardKey(),
RoutingDelegate: call.RoutingDelegate(),
RoutingKey: call.RoutingKey(),
}
} | |
c178354 |
// is marked as failed if the request has failed so that we don't try to shutdown the exchange
// a second time.
call.response.err = call.err
}
return call.response
} | |
c178355 | response.doneSending()
response.call.releasePreviousFragment()
span := CurrentSpan(response.mex.ctx)
return response.conn.SendSystemError(response.mex.msgID, *span, err)
} | |
c178356 |
state: response.state,
expectedState: reqResWriterPreArg2,
})
}
response.applicationError = true
return nil
} | |
c178357 | nil {
return nil, err
}
return response.arg2Writer()
} | |
c178358 | response.statsReporter.IncCounter("inbound.calls.app-errors", response.commonStatsTags, 1)
} else {
response.statsReporter.IncCounter("inbound.calls.success", response.commonStatsTags, 1)
}
// Cancel the context since the response is complete.
response.cancel()
// The message exchange is still open if there are no errors, call shutdown.
if response.err == nil {
response.mex.shutdown()
}
} | |
c178359 | i64Type := &parser.Type{Name: "i64"}
for k := range v.Enums {
typedefs[k] = i64Type
}
return &State{typedefs, nil, all}
} | |
c178360 | != nil {
return state.rootType(newType)
}
if v, ok := s.typedefs[thriftType.Name]; ok {
return s.rootType(v)
}
return thriftType
} | |
c178361 | *thriftType
newType.Name = parts[1]
include := s.includes[parts[0]]
state := s.all[include.file]
return state.global, &newType, include
} | |
c178362 | := thriftToGo[s.rootType(thriftType).Name]
return !basicGoType
} | |
c178363 | s.goTypePrefix("", thriftType)
} | |
c178364 |
// If the type is a direct Go type, use that.
if goType, ok := thriftToGo[thriftType.Name]; ok {
return goType
}
goThriftName := goPublicFieldName(thriftType.Name)
goThriftName = prefix + goThriftName
// Check if the type has a typedef to the direct Go type.
rootType := s.rootType(thriftType)
if _, ok := thriftToGo[rootType.Name]; ok {
return goThriftName
}
if rootType.Name == "list" ||
rootType.Name == "set" ||
rootType.Name == "map" {
return goThriftName
}
// If it's a typedef to another struct, then the typedef is defined as a pointer
// so we do not want the pointer type here.
if rootType != thriftType {
return goThriftName
}
// If it's not a typedef for a basic type, we use a pointer.
return "*" + goThriftName
} | |
c178365 | NewContextBuilder(timeout).Build()
} | |
c178366 | NewContextBuilder(timeout).
setIncomingCall(call).
Build()
} | |
c178367 | nil {
return params.call
}
return nil
} | |
c178368 | rand.New(&lockedSource{src: rand.NewSource(seed)})
} | |
c178369 |
return &meta.HealthStatus{Ok: ok}, nil
}
return &meta.HealthStatus{Ok: ok, Message: &message}, nil
} | |
c178370 |
return h.reqHeaders
}
return nil
} | |
c178371 | {
return h.respHeaders
}
return nil
} | |
c178372 | return
}
panic("SetResponseHeaders called on ContextWithHeaders not created via WrapWithHeaders")
} | |
c178373 | c.headers(); h != nil {
headersCopy = *h
}
return Wrap(context.WithValue(c.Context, contextKeyHeaders, &headersCopy))
} | |
c178374 | container, we should create an empty one.
return WrapWithHeaders(ctx, nil)
} | |
c178375 | := context.WithValue(ctx, contextKeyHeaders, h)
return headerCtx{Context: newCtx}
} | |
c178376 | context.WithValue(context.WithValue(ctx, contextKeyTChannel, nil), contextKeyHeaders, nil)
} | |
c178377 | if !e.notified.CAS(false, true) {
return fmt.Errorf("cannot broadcast error: %v, already have: %v", err, e.err)
}
e.err = err
close(e.c)
return nil
} | |
c178378 | // Note: One slow reader processing a large request could stall the connection.
// If we see this, we need to increase the recvCh buffer size.
return GetContextError(mex.ctx.Err())
case <-mex.errCh.c:
// Select will randomly choose a case, but we want to prioritize
// sending a frame over the errCh. Try a non-blocking write.
select {
case mex.recvCh <- frame:
return nil
default:
}
return mex.errCh.err
}
} | |
c178379 | {
return nil, err
}
return frame, nil
case <-mex.ctx.Done():
return nil, GetContextError(mex.ctx.Err())
case <-mex.errCh.c:
// Select will randomly choose a case, but we want to prioritize
// receiving a frame over errCh. Try a non-blocking read.
select {
case frame := <-mex.recvCh:
if err := mex.checkFrame(frame); err != nil {
return nil, err
}
return frame, nil
default:
}
return nil, mex.errCh.err
}
} | |
c178380 | nil, err
}
return nil, errMsg
default:
// TODO(mmihic): Should be treated as a protocol error
mex.mexset.log.WithFields(
LogField{"header", frame.Header},
LogField{"expectedType", msgType},
LogField{"expectedID", mex.msgID},
).Warn("Received unexpected frame.")
return nil, errUnexpectedFrameType
}
} | |
c178381 | if mex.errChNotified.CAS(false, true) {
mex.errCh.Notify(errMexShutdown)
}
mex.mexset.removeExchange(mex.msgID)
} | |
c178382 | log.WithFields(LogField{"exchange", name}),
exchanges: make(map[uint32]*messageExchange),
expiredExchanges: make(map[uint32]struct{}),
}
} | |
c178383 | mexset.exchanges[mex.msgID]; ok {
return errDuplicateMex
}
mexset.exchanges[mex.msgID] = mex
return nil
} | |
c178384 | := mexset.log.WithFields(
LogField{"msgID", mex.msgID},
LogField{"msgType", mex.msgType},
LogField{"exchange", mexset.name},
)
if addErr == errMexSetShutdown {
logger.Warn("Attempted to create new mex after mexset shutdown.")
} else if addErr == errDuplicateMex {
logger.Warn("Duplicate msg ID for active and new mex.")
}
return nil, addErr
}
mexset.onAdded()
// TODO(mmihic): Put into a deadline ordered heap so we can garbage collected expired exchanges
return mex, nil
} | |
c178385 | delete(mexset.exchanges, msgID)
return true, false
}
if _, expired := mexset.expiredExchanges[msgID]; expired {
delete(mexset.expiredExchanges, msgID)
return false, true
}
return false, false
} | |
c178386 | ).Error("Tried to remove exchange multiple times")
return
}
// If the message exchange was found, then we perform clean up actions.
// These clean up actions can only be run once per exchange.
mexset.onRemoved()
} | |
c178387 | everytime we expire an exchange
found, expired := mexset.deleteExchange(msgID)
if found || expired {
// Record in expiredExchanges if we deleted the exchange.
mexset.expiredExchanges[msgID] = struct{}{}
}
mexset.Unlock()
if expired {
mexset.log.WithFields(LogField{"msgID", msgID}).Info("Exchange expired already")
}
mexset.onRemoved()
} | |
c178388 | nil {
mexset.log.WithFields(
LogField{"frameHeader", frame.Header.String()},
LogField{"frameSize", frame.Header.FrameSize()},
LogField{"exchange", mexset.name},
ErrField(err),
).Info("Failed to forward frame.")
return err
}
return nil
} | |
c178389 | make(map[uint32]*messageExchange, len(mexset.exchanges))
for k, mex := range mexset.exchanges {
exchangesCopy[k] = mex
}
return false, exchangesCopy
} | |
c178390 | want to shutdown the exchange as only the
// arg reader/writer should shutdown the exchange. Otherwise, our guarantee
// on sendChRefs that there's no references to sendCh is violated since
// readers/writers could still have a reference to sendCh even though
// we shutdown the exchange and called Done on sendChRefs.
if mex.errChNotified.CAS(false, true) {
mex.errCh.Notify(err)
}
}
} | |
c178391 |
f.Payload = f.buffer[FrameHeaderSize:]
f.headerBuffer = f.buffer[:FrameHeaderSize]
return f
} | |
c178392 | f.Header.PayloadSize(); {
case payloadSize > MaxFramePayloadSize:
return fmt.Errorf("invalid frame size %v", f.Header.size)
case payloadSize > 0:
_, err := io.ReadFull(r, f.SizedPayload())
return err
default:
// No payload to read
return nil
}
} | |
c178393 | }
fullFrame := f.buffer[:f.Header.FrameSize()]
if _, err := w.Write(fullFrame); err != nil {
return err
}
return nil
} | |
c178394 | RetryConnectionError:
return code == ErrCodeNetwork
case RetryUnexpected:
return code == ErrCodeUnexpected
case RetryIdempotent:
return true
}
return false
} | |
c178395 | rs.Attempt < rOpts.MaxAttempts && rOpts.RetryOn.CanRetry(err)
} | |
c178396 | return fallback
}
return now.Sub(rs.Start)
} | |
c178397 | {},
}
} else {
rs.SelectedPeers[hostPort] = struct{}{}
rs.SelectedPeers[host] = struct{}{}
}
} | |
c178398 |
if ch.log.Enabled(LogLevelInfo) {
ch.log.WithFields(ErrField(err)).Info("Failed after non-retriable error.")
}
return err
}
ch.log.WithFields(
ErrField(err),
LogField{"attempt", rs.Attempt},
LogField{"maxAttempts", opts.MaxAttempts},
).Info("Retrying request after retryable error.")
}
// Too many retries, return the last error
return err
} | |
c178399 | 0
case ChecksumTypeCrc32, ChecksumTypeCrc32C:
return crc32.Size
case ChecksumTypeFarmhash:
return 4
default:
return 0
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.