id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c10500 | s := t.subscriber
t.lock.RUnlock()
return s
} | |
c10501 |
}
return fmt.Sprintf("Hello_Echo_Args{%v}", strings.Join(fields[:i], ", "))
} | |
c10502 | (v.Echo != nil && rhs.Echo != nil && v.Echo.Equals(rhs.Echo))) {
return false
}
return true
} | |
c10503 | err = multierr.Append(err, enc.AddObject("echo", v.Echo))
}
return err
} | |
c10504 | nil {
return v.Echo
}
return
} | |
c10505 |
return &Status{
code: code,
message: sprintf(format, args...),
}
} | |
c10506 |
}
return &Status{
code: CodeUnknown,
message: err.Error(),
}
} | |
c10507 | make(map[string]*compiledPeerListSpec),
knownPeerListUpdaters: make(map[string]*compiledPeerListUpdaterSpec),
resolver: os.LookupEnv,
}
for _, opt := range opts {
opt(c)
}
return c
} | |
c10508 | TransportSpec for %q: %v", t.Name, err)
}
c.knownTransports[t.Name] = spec
return nil
} | |
c10509 | := c.RegisterTransport(t); err != nil {
panic(err)
}
} | |
c10510 | PeerChooserSpec for %q: %v", s.Name, err)
}
c.knownPeerChoosers[s.Name] = spec
return nil
} | |
c10511 | := c.RegisterPeerChooser(s); err != nil {
panic(err)
}
} | |
c10512 | PeerListSpec for %q: %v", s.Name, err)
}
c.knownPeerLists[s.Name] = spec
return nil
} | |
c10513 | := c.RegisterPeerList(s); err != nil {
panic(err)
}
} | |
c10514 | PeerListUpdaterSpec for %q: %v", s.Name, err)
}
c.knownPeerListUpdaters[s.Name] = spec
return nil
} | |
c10515 | := c.RegisterPeerListUpdater(s); err != nil {
panic(err)
}
} | |
c10516 | if err != nil {
return nil, err
}
return yarpc.NewDispatcher(cfg), nil
} | |
c10517 | if err != nil {
return nil, err
}
return yarpc.NewDispatcher(cfg), nil
} | |
c10518 | return nil, fmt.Errorf("unknown transport %q", name)
}
return spec, nil
} | |
c10519 | nil {
return nil, err
}
defer outbound.Stop()
// TODO use yarpc.Service for caller
client := json.New(clientconfig.MultiOutbound("yarpc-test", body.Service, transport.Outbounds{
Unary: outbound,
}))
resBody := PhoneResponse{
Service: "yarpc-test", // TODO use yarpc.Service
Procedure: yarpc.CallFromCon... | |
c10520 |
apachethrift.Start()
oneway.Start()
googlegrpc.Start()
} | |
c10521 |
apachethrift.Stop()
oneway.Stop()
googlegrpc.Stop()
} | |
c10522 | range s.Functions {
if _, taken := added[f.ThriftName]; taken {
continue
}
functions = append(functions, f)
}
}
return functions
} | |
c10523 | return s.Parents[0].Service
}
return nil
} | |
c10524 | fmt.Sprintf("%s/%sserver", s.Module.ImportPath, strings.ToLower(s.Name))
} | |
c10525 | ""
}
return d.Parents[0].ServerPackagePath()
} | |
c10526 | ""
}
return d.Parents[0].ClientPackagePath()
} | |
c10527 | := random.String(5)
pong, err := client.Echo(wrap(ctx), &crossdockpb.Ping{Beep: token})
crossdock.Fatals(t).NoError(err, "call to Echo::echo failed: %v", err)
crossdock.Assert(t).Equal(token, pong.Boop, "server said: %v", pong.Boop)
} | |
c10528 | o, ok := o.Oneway.(introspection.IntrospectableOutbound); ok {
status = o.Introspect()
} else {
status.Transport = "Introspection not supported"
}
status.RPCType = "oneway"
status.Service = o.ServiceName
status.OutboundKey = outboundKey
outbounds = append(outbounds, status)
}
}
procedures... | |
c10529 |
return &HTTPServer{
Server: s,
done: make(chan error, 1),
}
} | |
c10530 |
h.lock.RUnlock()
return listener
} | |
c10531 | h.shutdownServer(ctx)
if !wasRunning {
return nil
}
serveErr := <-h.done // wait until Serve() stops
if closeErr != nil {
return closeErr
}
return serveErr
} | |
c10532 | &Dialer{trans: t, options: newDialOptions(options)}
} | |
c10533 | return d.trans.retainPeer(id, d.options, ps)
} | |
c10534 |
return d.trans.ReleasePeer(id, ps)
} | |
c10535 |
k.nextError = nil
}
k.Unlock()
return &examplepb.GetValueResponse{Value: value}, nextError
}
k.RUnlock()
return nil, yarpcerrors.Newf(yarpcerrors.CodeNotFound, request.Key)
} | |
c10536 |
delete(k.items, request.Key)
} else {
k.items[request.Key] = request.Value
}
var nextError error
if k.nextError != nil {
nextError = k.nextError
k.nextError = nil
}
k.Unlock()
return nil, nextError
} | |
c10537 |
defer k.Unlock()
k.nextError = err
} | |
c10538 | struct{})
}
return &SinkYARPCServer{sync.RWMutex{}, make([]string, 0), fireDone}
} | |
c10539 | }
select {
case s.fireDone <- struct{}{}:
case <-time.After(FireDoneTimeout):
return yarpcerrors.Newf(yarpcerrors.CodeDeadlineExceeded, "fire done not handled after %v", FireDoneTimeout)
}
return nil
} | |
c10540 | copy(values, s.values)
s.RUnlock()
return values
} | |
c10541 | return yarpcerrors.Newf(yarpcerrors.CodeDeadlineExceeded, "fire not done after %v", FireDoneTimeout)
}
return nil
} | |
c10542 | return nil, err
}
if request == nil {
return nil, errRequestNil
}
if request.Message == "" {
return nil, errRequestMessageNil
}
allMessages = append(allMessages, request.Message)
}
return &examplepb.EchoOutResponse{
AllMessages: allMessages,
}, nil
} | |
c10543 | != v {
return yarpcerrors.InvalidArgumentErrorf("did not receive proper headers, missing %q:%q", k, v)
}
}
for i := 0; i < int(request.NumResponses); i++ {
if err := server.Send(&examplepb.EchoInResponse{Message: request.Message}); err != nil {
return err
}
}
return nil
} | |
c10544 | return errRequestNil
}
if request.Message == "" {
return errRequestMessageNil
}
if request.NumResponses == 0 {
return errRequestNumResponsesNil
}
for i := 0; i < int(request.NumResponses); i++ {
if err := server.Send(&examplepb.EchoBothResponse{Message: request.Message}); err != nil {
return ... | |
c10545 | lifecycle.NewOnce(),
transport: t,
chooser: chooser,
}
} | |
c10546 | := peerchooser.NewSingle(hostport.PeerIdentifier(addr), t)
return t.NewOutbound(chooser)
} | |
c10547 | root.GetOrAdd(p.HostPort())
return callWithPeer(ctx, req, tp, p.transport.headerCase)
} | |
c10548 |
if err := writeBody(req.Body, call); err != nil {
return nil, err
}
res := call.Response()
headers, err := readHeaders(format, res.Arg2Reader)
if err != nil {
if err, ok := err.(tchannel.SystemError); ok {
return nil, fromSystemError(err)
}
// TODO(abg): This will wrap IO errors while reading headers... | |
c10549 | {
return o.once.Start(o.chooser.Start)
} | |
c10550 | {
return o.once.Stop(o.chooser.Stop)
} | |
c10551 | fmt.Sprintf("%s::%s", serviceName, methodName)
} | |
c10552 | {
return parts[0], ""
}
return parts[0], parts[1]
} | |
c10553 | plOpts = append(plOpts, peerlist.NoShuffle())
}
nextRandFn := nextRand(cfg.seed)
if cfg.nextRand != nil {
// only true in tests
nextRandFn = cfg.nextRand
}
return &List{
List: peerlist.New(
"fewest-pending-requests",
transport,
&pendingHeap{
nextRand: nextRandFn,
},
plOpts...,
),
}
... | |
c10554 | if numPeers == 0 {
return 0
}
return r.Intn(numPeers)
}
} | |
c10555 | v.Key)
i++
if v.Message != nil {
fields[i] = fmt.Sprintf("Message: %v", *(v.Message))
i++
}
return fmt.Sprintf("ResourceDoesNotExist{%v}", strings.Join(fields[:i], ", "))
} | |
c10556 | return false
}
if !_String_EqualsPtr(v.Message, rhs.Message) {
return false
}
return true
} | |
c10557 | == nil {
return nil
}
enc.AddString("key", v.Key)
if v.Message != nil {
enc.AddString("message", *v.Message)
}
return err
} | |
c10558 |
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.KeyValue",
ClientConfig: clientConfig,
Options: options,
},
)}
} | |
c10559 | protobuf.UnaryHandlerParams{
Handle: handler.SetValue,
NewRequest: newKeyValueServiceSetValueYARPCRequest,
},
),
},
},
OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{},
StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{},
},
)
} | |
c10560 |
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Sink",
ClientConfig: clientConfig,
Options: options,
},
)}
} | |
c10561 | OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{
{
MethodName: "Fire",
Handler: protobuf.NewOnewayHandler(
protobuf.OnewayHandlerParams{
Handle: handler.Fire,
NewRequest: newSinkServiceFireYARPCRequest,
},
),
},
},
StreamHandlerParams: []p... | |
c10562 |
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Foo",
ClientConfig: clientConfig,
Options: options,
},
)}
} | |
c10563 | Handler: protobuf.NewStreamHandler(
protobuf.StreamHandlerParams{
Handle: handler.EchoIn,
},
),
},
{
MethodName: "EchoOut",
Handler: protobuf.NewStreamHandler(
protobuf.StreamHandlerParams{
Handle: handler.EchoOut,
},
),
},
},
},
)
} | |
c10564 | options.source = rand.NewSource(seed)
})
} | |
c10565 | listOptionFunc(func(options *listOptions) {
options.source = source
})
} | |
c10566 | rand.NewSource(time.Now().UnixNano())
}
plOpts := []peerlist.ListOption{
peerlist.Capacity(options.capacity),
peerlist.NoShuffle(),
}
return &List{
List: peerlist.New(
"random",
transport,
newRandomList(options.capacity, options.source),
plOpts...,
),
}
} | |
c10567 | if err := f(); err != nil {
ew.lock.Lock()
ew.errors = append(ew.errors, err)
ew.lock.Unlock()
}
}()
} | |
c10568 | HandlerSpec: transport.NewUnaryHandlerSpec(rawUnaryHandler{handler}),
},
}
} | |
c10569 | HandlerSpec: transport.NewOnewayHandlerSpec(rawOnewayHandler{handler}),
},
}
} | |
c10570 | time.Sleep(1 * time.Second)
return nil, nil
} | |
c10571 | deadline set in context")
}
<-ctx.Done()
return nil, ctx.Err()
} | |
c10572 | newClientEncodingError(req, false /*isResponse*/, false /*isHeader*/, err)
} | |
c10573 | newClientEncodingError(req, false /*isResponse*/, true /*isHeader*/, err)
} | |
c10574 | newClientEncodingError(req, true /*isResponse*/, true /*isHeader*/, err)
} | |
c10575 | unmarshal(stream.Request().Meta.Encoding, streamMsg.Body, message); err != nil {
streamMsg.Body.Close()
return nil, err
}
if streamMsg.Body != nil {
streamMsg.Body.Close()
}
return message, nil
} | |
c10576 | ctx,
&transport.StreamMessage{
Body: readCloser{Reader: bytes.NewReader(messageData), closer: cleanup},
},
)
} | |
c10577 | newHandler(dispatcher, opts...).handle
} | |
c10578 | ph.peers[j] = ph.peers[j], ph.peers[i]
p1.idx = j
p2.idx = i
} | |
c10579 | len(ph.peers)
ph.peers = append(ph.peers, ps)
} | |
c10580 | - 1
last := ph.peers[lastIdx]
ph.peers = ph.peers[:lastIdx]
return last
} | |
c10581 | := io.ReadFull(rand.Reader, out); err != nil {
panic(err)
}
return out
} | |
c10582 | se64.RawStdEncoding.EncodeToString(Bytes(length))[:length]
} | |
c10583 |
if ok {
return s
}
return strconv.Itoa(int(c))
} | |
c10584 | t)
o := t.NewOutbound(chooser)
for _, opt := range opts {
opt(o)
}
o.setURLTemplate(uri)
return o
} | |
c10585 | return nil, yarpcerrors.InvalidArgumentErrorf("request for http unary outbound was nil")
}
return o.call(ctx, treq)
} | |
c10586 | }
_, err := o.call(ctx, treq)
if err != nil {
return nil, err
}
return time.Now(), nil
} | |
c10587 | {
serviceName := resHeaders.Get(ServiceHeader)
return serviceName == "" || serviceName == reqSvcName, serviceName
} | |
c10588 | i++
}
if v.RoutingKey != nil {
fields[i] = fmt.Sprintf("RoutingKey: %v", *(v.RoutingKey))
i++
}
if v.RoutingDelegate != nil {
fields[i] = fmt.Sprintf("RoutingDelegate: %v", *(v.RoutingDelegate))
i++
}
if v.Body != nil {
fields[i] = fmt.Sprintf("Body: %v", v.Body)
i++
}
return fmt.Sprintf("RPC{%v}... | |
c10589 | !_String_EqualsPtr(v.ShardKey, rhs.ShardKey) {
return false
}
if !_String_EqualsPtr(v.RoutingKey, rhs.RoutingKey) {
return false
}
if !_String_EqualsPtr(v.RoutingDelegate, rhs.RoutingDelegate) {
return false
}
if !((v.Body == nil && rhs.Body == nil) || (v.Body != nil && rhs.Body != nil && bytes.Equal(v.Bod... | |
c10590 | m {
enc.AddString((string)(k), v)
}
return err
} | |
c10591 | if v.Headers != nil {
err = multierr.Append(err, enc.AddObject("headers", (_Map_String_String_Zapper)(v.Headers)))
}
if v.ShardKey != nil {
enc.AddString("shardKey", *v.ShardKey)
}
if v.RoutingKey != nil {
enc.AddString("routingKey", *v.RoutingKey)
}
if v.RoutingDelegate != nil {
enc.AddString("routingDe... | |
c10592 | o = v.SpanContext
}
return
} | |
c10593 | o = v.CallerName
}
return
} | |
c10594 | o = v.ServiceName
}
return
} | |
c10595 | o = v.Encoding
}
return
} | |
c10596 | o = v.Procedure
}
return
} | |
c10597 | nil {
return v.Headers
}
return
} | |
c10598 | return *v.ShardKey
}
return
} | |
c10599 | return *v.RoutingKey
}
return
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.