id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c10600 | return *v.RoutingDelegate
}
return
} | |
c10601 | v != nil && v.Body != nil {
return v.Body
}
return
} | |
c10602 | peerlist.Capacity(cfg.capacity),
peerlist.Seed(cfg.seed),
}
if !cfg.shuffle {
plOpts = append(plOpts, peerlist.NoShuffle())
}
return &List{
List: peerlist.New(
"roundrobin",
transport,
newPeerRing(),
plOpts...,
),
}
} | |
c10603 | errors.ExpectEncodings(treq, Encoding); err != nil {
return wire.Value{}, nil, err
}
if err := call.ReadFromRequest(treq); err != nil {
// not reachable
return wire.Value{}, nil, err
}
if _, err := buf.ReadFrom(treq.Body); err != nil {
return wire.Value{}, nil, err
}
reader := bytes.NewReader(buf.Byte... | |
c10604 | verifyUnarySignature(name, reflect.TypeOf(handler))
return newJSONHandler(reqBodyType, handler)
} | |
c10605 | verifyOnewaySignature(name, reflect.TypeOf(handler))
return newJSONHandler(reqBodyType, handler)
} | |
c10606 | if !isValidReqResType(resBodyType) {
panic(fmt.Sprintf(
"the first result of the handler for %q must be "+
"a struct pointer, a map[string]interface{}, or interface{], and not: %v",
n, resBodyType,
))
}
return reqBodyType
} | |
c10607 | ))
}
if t.Out(0) != _errorType {
panic(fmt.Sprintf(
"the result of the handler for %q must be of type error, and not: %v",
n, t.Out(0),
))
}
return reqBodyType
} | |
c10608 | and not: %v", n, t.In(0),
))
}
reqBodyType := t.In(1)
if !isValidReqResType(reqBodyType) {
panic(fmt.Sprintf(
"the second argument of the handler for %q must be "+
"a struct pointer, a map[string]interface{}, or interface{}, and not: %v",
n, reqBodyType,
))
}
return reqBodyType
} | |
c10609 | t,
listener: listener,
options: newInboundOptions(options),
}
} | |
c10610 | for safety
if i.server == nil || i.listener == nil {
return nil
}
return i.listener.Addr()
} | |
c10611 | defaultConnTimeout,
connBackoffStrategy: backoff.DefaultExponential,
}
} | |
c10612 | *transportOptions) {
t.tracer = tracer
}
} | |
c10613 | *transportOptions) {
options.connTimeout = d
}
} | |
c10614 | *transportOptions) {
options.connBackoffStrategy = s
}
} | |
c10615 |
unaryOutbound = tchannelTransport.NewSingleOutbound(server + ":8082")
case "grpc":
unaryOutbound = grpc.NewTransport().NewSingleOutbound(server + ":8089")
default:
fatals.Fail("", "unknown transport %q", trans)
}
return yarpc.NewDispatcher(yarpc.Config{
Name: "client",
Outbounds: yarpc.Outbounds{
"ya... | |
c10616 |
d.bs = d.bs[:0]
return d
} | |
c10617 | append(d.bs, '\x00')
}
d.bs = append(d.bs, s...)
} | |
c10618 | }
}
}
f := &File{
FileDescriptorProto: file,
GoPackage: pkg,
}
r.files[file.GetName()] = f
r.registerMsg(f, nil, file.GetMessageType())
r.registerEnum(f, nil, file.GetEnumType())
} | |
c10619 |
files, err := r.loadTransitiveFileDependenciesRecurse(file, seen)
if err != nil {
return err
}
file.TransitiveDependencies = files
return nil
} | |
c10620 | lifecycle.NewOnce(),
transport: t,
}
} | |
c10621 | = fmt.Sprintf("Value: %v", *(v.Value))
i++
}
return fmt.Sprintf("KeyValue_SetValue_Args{%v}", strings.Join(fields[:i], ", "))
} | |
c10622 | return false
}
if !_String_EqualsPtr(v.Value, rhs.Value) {
return false
}
return true
} | |
c10623 |
}
if v.Value != nil {
enc.AddString("value", *v.Value)
}
return err
} | |
c10624 | nil {
return *v.Value
}
return
} | |
c10625 | {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
return true
} | |
c10626 |
span := c.Tracer.StartSpan(
req.Procedure,
opentracing.StartTime(c.StartTime),
opentracing.ChildOf(parent),
tags,
)
ext.PeerService.Set(span, req.Service)
ext.SpanKindRPCClient.Set(span)
ctx = opentracing.ContextWithSpan(ctx, span)
return ctx, span
} | |
c10627 | nil
// this implies ChildOf
ext.RPCServerOption(e.ParentSpanContext),
)
ext.PeerService.Set(span, req.Caller)
ext.SpanKindRPCServer.Set(span)
ctx = opentracing.ContextWithSpan(ctx, span)
return ctx, span
} | |
c10628 | nil {
span.SetTag("error", true)
span.LogFields(opentracinglog.String("event", err.Error()))
}
return err
} | |
c10629 | g.extract,
started: now,
ctx: ctx,
req: req,
rpcType: rpcType,
direction: direction,
succLevel: g.succLevel,
failLevel: g.failLevel,
appErrLevel: g.appErrLevel,
}
} | |
c10630 | *exponentialOptions) {
options.first = t
}
} | |
c10631 | *exponentialOptions) {
options.max = t
}
} | |
c10632 | *exponentialOptions) {
options.newRand = newRand
}
} | |
c10633 | e.opts.max.Nanoseconds(),
rand: e.opts.newRand(),
}
} | |
c10634 |
if e.opts.max != o.opts.max {
return false
}
return true
} | |
c10635 | ensures that the upper bound of the range of
// possible durations includes the maximum.
return time.Duration(e.rand.Int63n(spread + 1))
} | |
c10636 | {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
return true
} | |
c10637 | {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
return true
} | |
c10638 | lifecycle.NewOnce(),
chooserList: chooserList,
updater: bind(chooserList),
}
} | |
c10639 | err error) {
return c.chooserList.Choose(ctx, treq)
} | |
c10640 | c.chooserList.IsRunning() && c.updater.IsRunning()
} | |
c10641 | return ic.Introspect()
}
return introspection.ChooserStatus{}
} | |
c10642 | len(unchained) {
case 0:
return middleware.NopUnaryOutbound
case 1:
return unchained[0]
default:
return unaryChain(unchained)
}
} | |
c10643 | switch len(unchained) {
case 0:
return middleware.NopOnewayOutbound
case 1:
return unchained[0]
default:
return onewayChain(unchained)
}
} | |
c10644 | switch len(unchained) {
case 0:
return middleware.NopStreamOutbound
case 1:
return unchained[0]
default:
return streamChain(unchained)
}
} | |
c10645 | t.In(1))
case t.In(2) != _typeOfKit:
return fmt.Errorf("must accept a %v as its third argument, found %v", _typeOfKit, t.In(2))
case t.NumOut() != 2:
return fmt.Errorf("must return exactly two results, found %v", t.NumOut())
case t.Out(0) != outputType:
return fmt.Errorf("must return a %v as its first result,... | |
c10646 | := results[0].Interface().(peer.Chooser)
err, _ := results[1].Interface().(error)
return chooser, err
} | |
c10647 | return nil, fmt.Errorf("failed to decode %v: %v", cs.inputType, err)
}
return &buildable{factory: cs.factory, inputData: inputConfig.Elem()}, nil
} | |
c10648 | callArgs[i+1] = reflect.ValueOf(v)
}
}
result := cv.factory.Call(callArgs)
err, _ := result[1].Interface().(error)
return result[0].Interface(), err
} | |
c10649 |
Encoding: string(p.Encoding),
Signature: p.Signature,
RPCType: p.HandlerSpec.Type().String(),
})
}
return procedures
} | |
c10650 | deadline, _ := i.Context.Deadline()
err = yarpcerrors.Newf(
yarpcerrors.CodeDeadlineExceeded,
"call to procedure %q of service %q from caller %q timed out after %v",
i.Request.Procedure, i.Request.Service, i.Request.Caller, deadline.Sub(i.StartTime))
}
return err
} | |
c10651 | handlePanic(Oneway, i.Logger, r, i.Request.ToRequestMeta())
}
}()
return i.Handler.HandleOneway(i.Context, i.Request)
} | |
c10652 | handlePanic(Streaming, i.Logger, r, i.Stream.Request().Meta)
}
}()
return i.Handler.HandleStream(i.Stream)
} | |
c10653 | t.Tag("server", t.Param(params.Server))
RunGauntlet(t, Config{
Dispatcher: dispatcher,
ServerName: serverName,
})
} | |
c10654 | server returned error: %v", desc, err)
}
} else {
if !checks.NoError(err, "%v: call failed", desc) {
return
}
if tt.Want != nil {
assert.Equal(tt.Want, got, "%v: server returned: %v", desc, got)
}
}
} | |
c10655 |
crossdock.Fatals(t).Fail("unknown encoding", "%v", encoding)
}
f(t, "grpc")
} | |
c10656 | != nil {
return nil, err
}
if err := transport.ValidateRequestContext(ctx); err != nil {
return nil, err
}
return o.UnaryOutbound.Call(ctx, request)
} | |
c10657 | != nil {
return nil, err
}
if err := transport.ValidateRequestContext(ctx); err != nil {
return nil, err
}
return o.OnewayOutbound.CallOneway(ctx, request)
} | |
c10658 | error) {
if err := transport.ValidateRequest(request.Meta.ToRequest()); err != nil {
return nil, err
}
return o.StreamOutbound.CallStream(ctx, request)
} | |
c10659 | bytes.Buffer
if err := s.RenderTo(&buff, resolve); err != nil {
return "", err
}
return buff.String(), nil
} | |
c10660 | } else {
return errUnknownVariable{Name: t.Name}
}
}
if _, err := io.WriteString(w, value); err != nil {
return err
}
}
return nil
} | |
c10661 | delete(headers, tchannel.ServiceHeaderKey)
} | |
c10662 | cancel()
ack, err := client.CallOneway(
ctx, "echo/raw", []byte{}, yarpc.WithHeader("callBackAddr", callBackAddr))
fatals.NoError(err, "call to oneway/raw failed: %v", err)
fatals.NotNil(ack, "ack is nil")
// wait for server to call us back
gotBaggage := <-serverCalledBack
assert.Equal(baggage, gotBaggage, "... | |
c10663 |
serverCalledBack <- extractBaggage(ctx)
return nil
}, serverCalledBack
} | |
c10664 | add the first node
pr.nextNode = newNode
} else {
// Push the node to the ring
pushBeforeNode(pr.nextNode, newNode)
}
return sub
} | |
c10665 | = nil
} else {
if pr.isNextNode(node) {
pr.nextNode = pr.nextNode.Next()
}
popNodeFromRing(node)
}
} | |
c10666 | if pr.nextNode == nil {
return nil
}
p := getPeerForRingNode(pr.nextNode)
pr.nextNode = pr.nextNode.Next()
return p
} | |
c10667 | ctx, func() {}, newInvalidTTLError(
req.Service,
req.Procedure,
fmt.Sprint(ttlms),
)
}
ctx, cancel = context.WithTimeout(ctx, time.Duration(ttlms)*time.Millisecond)
return ctx, cancel, nil
} | |
c10668 | pid,
t: transport,
}
s.boundOnFinish = s.onFinish
return s
} | |
c10669 | {
return nil, nil, err
}
s.p.StartRequest()
return s.p, s.boundOnFinish, s.err
} | |
c10670 | peerStatus.ConnectionStatus.String(),
peerStatus.PendingRequestCount),
}
return introspection.ChooserStatus{
Name: "Single",
Peers: []introspection.PeerStatus{peer},
}
} | |
c10671 | addObservingMiddleware(cfg, meter, logger, extractor)
return &Dispatcher{
name: cfg.Name,
table: middleware.ApplyRouteTable(NewMapRouter(cfg.Name), cfg.RouterMiddleware),
inbounds: cfg.Inbounds,
outbounds: convertOutbounds(cfg.Outbounds, cfg.OutboundMiddleware),
tr... | |
c10672 | = middleware.ApplyOnewayOutbound(outs.Oneway, mw.Oneway)
onewayOutbound = request.OnewayValidatorOutbound{OnewayOutbound: onewayOutbound}
}
if outs.Stream != nil {
streamOutbound = middleware.ApplyStreamOutbound(outs.Stream, mw.Stream)
streamOutbound = request.StreamValidatorOutbound{StreamOutbound: stre... | |
c10673 | != nil {
for _, transport := range unary.Transports() {
transports[transport] = struct{}{}
}
}
if oneway := outbound.Oneway; oneway != nil {
for _, transport := range oneway.Transports() {
transports[transport] = struct{}{}
}
}
if stream := outbound.Stream; stream != nil {
for _, transpo... | |
c10674 | make(Inbounds, len(d.inbounds))
copy(inbounds, d.inbounds)
return inbounds
} | |
c10675 | len(d.outbounds))
for k, v := range d.outbounds {
outbounds[k] = v
}
return outbounds
} | |
c10676 | d.inboundMiddleware.Oneway)
r.HandlerSpec = transport.NewOnewayHandlerSpec(h)
case transport.Streaming:
h := middleware.ApplyStreamInbound(r.HandlerSpec.Stream(),
d.inboundMiddleware.Stream)
r.HandlerSpec = transport.NewStreamHandlerSpec(h)
default:
panic(fmt.Sprintf("unknown handler type %q for ... | |
c10677 | return multierr.Combine(
stopper.StopInbounds(),
stopper.StopOutbounds(),
stopper.StopTransports(),
)
})
} | |
c10678 | v.Beep)
i++
return fmt.Sprintf("Ping{%v}", strings.Join(fields[:i], ", "))
} | |
c10679 | } else if rhs == nil {
return false
}
if !(v.Beep == rhs.Beep) {
return false
}
return true
} | |
c10680 | return nil
}
enc.AddString("beep", v.Beep)
return err
} | |
c10681 | o = v.Beep
}
return
} | |
c10682 | v.Boop)
i++
return fmt.Sprintf("Pong{%v}", strings.Join(fields[:i], ", "))
} | |
c10683 | } else if rhs == nil {
return false
}
if !(v.Boop == rhs.Boop) {
return false
}
return true
} | |
c10684 | return nil
}
enc.AddString("boop", v.Boop)
return err
} | |
c10685 | o = v.Boop
}
return
} | |
c10686 | {
t.Skipf("handlertimeout/raw procedure not implemented: %v", err)
return
}
assert.Equal(yarpcerrors.CodeDeadlineExceeded, yarpcerrors.FromError(err).Code(), "is an error with code CodeDeadlineExceeded: %v", err)
} | |
c10687 | conn != nil {
conn.Close()
}
if conn != nil && err == nil {
return true
}
return false
} | |
c10688 | ServiceName: service,
Unary: outbounds.Unary,
Oneway: outbounds.Oneway,
},
}
} | |
c10689 | }
if err := ch.ListenAndServe(hostPort); err != nil {
log.WithFields(
tchannel.LogField{Key: "hostPort", Value: hostPort},
tchannel.ErrField(err),
).Fatal("Couldn't listen.")
}
} | |
c10690 |
tserver.Register(gauntlet_tchannel.NewTChanThriftTestServer(&thriftTestHandler{}))
tserver.Register(gauntlet_tchannel.NewTChanSecondServiceServer(&secondServiceHandler{}))
return nil
} | |
c10691 | close(o.stoppingCh)
close(o.stopCh)
} else {
o.state.Store(int32(Running))
}
close(o.startCh)
return err
}
<-o.startCh
return o.loadError()
} | |
c10692 | return nil
}
return yarpcerrors.FailedPreconditionErrorf("instance did not enter running state, current state is %q", getStateName(state))
case <-ctx.Done():
return yarpcerrors.FailedPreconditionErrorf("context finished while waiting for instance to start: %s", ctx.Err().Error())
}
} | |
c10693 | o.setError(err)
o.state.Store(int32(Errored))
} else {
o.state.Store(int32(Stopped))
}
close(o.stopCh)
return err
}
<-o.stopCh
return o.loadError()
} | |
c10694 |
t.Tag("encoding", encoding)
t.Tag("server", t.Param(params.Server))
return t
} | |
c10695 | return newInbound(t, listener, options...)
} | |
c10696 | return newOutbound(t, peerChooser, options...)
} | |
c10697 | &service{d}
d.Register(ms.Procedures())
} | |
c10698 | r []transport.Procedure
for _, m := range methods {
p := json.Procedure(m.Name, m.Handler)[0]
p.Signature = m.Signature
r = append(r, p)
}
return r
} | |
c10699 | lifecycle.NewOnce(),
channel: t.ch,
transport: t,
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.