id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
10,900 |
yarpc/yarpc-go
|
transport/http/transport.go
|
buildClient
|
func buildClient(f func(*transportOptions) *http.Client) TransportOption {
return func(options *transportOptions) {
options.buildClient = f
}
}
|
go
|
func buildClient(f func(*transportOptions) *http.Client) TransportOption {
return func(options *transportOptions) {
options.buildClient = f
}
}
|
[
"func",
"buildClient",
"(",
"f",
"func",
"(",
"*",
"transportOptions",
")",
"*",
"http",
".",
"Client",
")",
"TransportOption",
"{",
"return",
"func",
"(",
"options",
"*",
"transportOptions",
")",
"{",
"options",
".",
"buildClient",
"=",
"f",
"\n",
"}",
"\n",
"}"
] |
// Hidden option to override the buildHTTPClient function. This is used only
// for testing.
|
[
"Hidden",
"option",
"to",
"override",
"the",
"buildHTTPClient",
"function",
".",
"This",
"is",
"used",
"only",
"for",
"testing",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/http/transport.go#L205-L209
|
10,901 |
yarpc/yarpc-go
|
transport/http/transport.go
|
NewTransport
|
func NewTransport(opts ...TransportOption) *Transport {
options := newTransportOptions()
for _, opt := range opts {
opt(&options)
}
return options.newTransport()
}
|
go
|
func NewTransport(opts ...TransportOption) *Transport {
options := newTransportOptions()
for _, opt := range opts {
opt(&options)
}
return options.newTransport()
}
|
[
"func",
"NewTransport",
"(",
"opts",
"...",
"TransportOption",
")",
"*",
"Transport",
"{",
"options",
":=",
"newTransportOptions",
"(",
")",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"&",
"options",
")",
"\n",
"}",
"\n",
"return",
"options",
".",
"newTransport",
"(",
")",
"\n",
"}"
] |
// NewTransport creates a new HTTP transport for managing peers and sending requests
|
[
"NewTransport",
"creates",
"a",
"new",
"HTTP",
"transport",
"for",
"managing",
"peers",
"and",
"sending",
"requests"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/http/transport.go#L212-L218
|
10,902 |
yarpc/yarpc-go
|
transport/http/transport.go
|
Stop
|
func (a *Transport) Stop() error {
return a.once.Stop(func() error {
a.connectorsGroup.Wait()
return nil
})
}
|
go
|
func (a *Transport) Stop() error {
return a.once.Stop(func() error {
a.connectorsGroup.Wait()
return nil
})
}
|
[
"func",
"(",
"a",
"*",
"Transport",
")",
"Stop",
"(",
")",
"error",
"{",
"return",
"a",
".",
"once",
".",
"Stop",
"(",
"func",
"(",
")",
"error",
"{",
"a",
".",
"connectorsGroup",
".",
"Wait",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"}"
] |
// Stop stops the HTTP transport.
|
[
"Stop",
"stops",
"the",
"HTTP",
"transport",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/http/transport.go#L289-L294
|
10,903 |
yarpc/yarpc-go
|
peer/x/peerheap/list.go
|
StartupWait
|
func StartupWait(t time.Duration) HeapOption {
return func(c *heapConfig) {
c.startupWait = t
}
}
|
go
|
func StartupWait(t time.Duration) HeapOption {
return func(c *heapConfig) {
c.startupWait = t
}
}
|
[
"func",
"StartupWait",
"(",
"t",
"time",
".",
"Duration",
")",
"HeapOption",
"{",
"return",
"func",
"(",
"c",
"*",
"heapConfig",
")",
"{",
"c",
".",
"startupWait",
"=",
"t",
"\n",
"}",
"\n",
"}"
] |
// StartupWait specifies how long updates to the heap will block
// before the list heap been started
//
// Defaults to 5 seconds.
|
[
"StartupWait",
"specifies",
"how",
"long",
"updates",
"to",
"the",
"heap",
"will",
"block",
"before",
"the",
"list",
"heap",
"been",
"started",
"Defaults",
"to",
"5",
"seconds",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/x/peerheap/list.go#L58-L62
|
10,904 |
yarpc/yarpc-go
|
peer/x/peerheap/list.go
|
New
|
func New(transport peer.Transport, opts ...HeapOption) *List {
cfg := defaultHeapConfig
for _, o := range opts {
o(&cfg)
}
return &List{
once: lifecycle.NewOnce(),
transport: transport,
byIdentifier: make(map[string]*peerScore),
peerAvailableEvent: make(chan struct{}, 1),
startupWait: cfg.startupWait,
}
}
|
go
|
func New(transport peer.Transport, opts ...HeapOption) *List {
cfg := defaultHeapConfig
for _, o := range opts {
o(&cfg)
}
return &List{
once: lifecycle.NewOnce(),
transport: transport,
byIdentifier: make(map[string]*peerScore),
peerAvailableEvent: make(chan struct{}, 1),
startupWait: cfg.startupWait,
}
}
|
[
"func",
"New",
"(",
"transport",
"peer",
".",
"Transport",
",",
"opts",
"...",
"HeapOption",
")",
"*",
"List",
"{",
"cfg",
":=",
"defaultHeapConfig",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"opts",
"{",
"o",
"(",
"&",
"cfg",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"List",
"{",
"once",
":",
"lifecycle",
".",
"NewOnce",
"(",
")",
",",
"transport",
":",
"transport",
",",
"byIdentifier",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"peerScore",
")",
",",
"peerAvailableEvent",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"1",
")",
",",
"startupWait",
":",
"cfg",
".",
"startupWait",
",",
"}",
"\n",
"}"
] |
// New returns a new peer heap-chooser-list for the given transport.
|
[
"New",
"returns",
"a",
"new",
"peer",
"heap",
"-",
"chooser",
"-",
"list",
"for",
"the",
"given",
"transport",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/x/peerheap/list.go#L97-L110
|
10,905 |
yarpc/yarpc-go
|
peer/x/peerheap/list.go
|
Update
|
func (pl *List) Update(updates peer.ListUpdates) error {
ctx, cancel := context.WithTimeout(context.Background(), pl.startupWait)
defer cancel()
if err := pl.once.WaitUntilRunning(ctx); err != nil {
return intyarpcerrors.AnnotateWithInfo(yarpcerrors.FromError(err), "%s peer list is not running", "peer heap")
}
var errs error
pl.mu.Lock()
defer pl.mu.Unlock()
for _, pid := range updates.Removals {
errs = multierr.Append(errs, pl.releasePeer(pid))
}
for _, pid := range updates.Additions {
errs = multierr.Append(errs, pl.retainPeer(pid))
}
return errs
}
|
go
|
func (pl *List) Update(updates peer.ListUpdates) error {
ctx, cancel := context.WithTimeout(context.Background(), pl.startupWait)
defer cancel()
if err := pl.once.WaitUntilRunning(ctx); err != nil {
return intyarpcerrors.AnnotateWithInfo(yarpcerrors.FromError(err), "%s peer list is not running", "peer heap")
}
var errs error
pl.mu.Lock()
defer pl.mu.Unlock()
for _, pid := range updates.Removals {
errs = multierr.Append(errs, pl.releasePeer(pid))
}
for _, pid := range updates.Additions {
errs = multierr.Append(errs, pl.retainPeer(pid))
}
return errs
}
|
[
"func",
"(",
"pl",
"*",
"List",
")",
"Update",
"(",
"updates",
"peer",
".",
"ListUpdates",
")",
"error",
"{",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"context",
".",
"Background",
"(",
")",
",",
"pl",
".",
"startupWait",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"if",
"err",
":=",
"pl",
".",
"once",
".",
"WaitUntilRunning",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"intyarpcerrors",
".",
"AnnotateWithInfo",
"(",
"yarpcerrors",
".",
"FromError",
"(",
"err",
")",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"errs",
"error",
"\n\n",
"pl",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pl",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"pid",
":=",
"range",
"updates",
".",
"Removals",
"{",
"errs",
"=",
"multierr",
".",
"Append",
"(",
"errs",
",",
"pl",
".",
"releasePeer",
"(",
"pid",
")",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"pid",
":=",
"range",
"updates",
".",
"Additions",
"{",
"errs",
"=",
"multierr",
".",
"Append",
"(",
"errs",
",",
"pl",
".",
"retainPeer",
"(",
"pid",
")",
")",
"\n",
"}",
"\n\n",
"return",
"errs",
"\n",
"}"
] |
// Update satisfies the peer.List interface, so a peer list updater can manage
// the retained peers.
|
[
"Update",
"satisfies",
"the",
"peer",
".",
"List",
"interface",
"so",
"a",
"peer",
"list",
"updater",
"can",
"manage",
"the",
"retained",
"peers",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/x/peerheap/list.go#L114-L135
|
10,906 |
yarpc/yarpc-go
|
peer/x/peerheap/list.go
|
retainPeer
|
func (pl *List) retainPeer(pid peer.Identifier) error {
if _, ok := pl.byIdentifier[pid.Identifier()]; ok {
return peer.ErrPeerAddAlreadyInList(pid.Identifier())
}
ps := &peerScore{id: pid, list: pl}
p, err := pl.transport.RetainPeer(pid, ps)
if err != nil {
return err
}
ps.peer = p
ps.score = scorePeer(p)
ps.boundFinish = ps.finish
pl.byIdentifier[pid.Identifier()] = ps
pl.byScore.pushPeer(ps)
pl.internalNotifyStatusChanged(ps)
return nil
}
|
go
|
func (pl *List) retainPeer(pid peer.Identifier) error {
if _, ok := pl.byIdentifier[pid.Identifier()]; ok {
return peer.ErrPeerAddAlreadyInList(pid.Identifier())
}
ps := &peerScore{id: pid, list: pl}
p, err := pl.transport.RetainPeer(pid, ps)
if err != nil {
return err
}
ps.peer = p
ps.score = scorePeer(p)
ps.boundFinish = ps.finish
pl.byIdentifier[pid.Identifier()] = ps
pl.byScore.pushPeer(ps)
pl.internalNotifyStatusChanged(ps)
return nil
}
|
[
"func",
"(",
"pl",
"*",
"List",
")",
"retainPeer",
"(",
"pid",
"peer",
".",
"Identifier",
")",
"error",
"{",
"if",
"_",
",",
"ok",
":=",
"pl",
".",
"byIdentifier",
"[",
"pid",
".",
"Identifier",
"(",
")",
"]",
";",
"ok",
"{",
"return",
"peer",
".",
"ErrPeerAddAlreadyInList",
"(",
"pid",
".",
"Identifier",
"(",
")",
")",
"\n",
"}",
"\n\n",
"ps",
":=",
"&",
"peerScore",
"{",
"id",
":",
"pid",
",",
"list",
":",
"pl",
"}",
"\n",
"p",
",",
"err",
":=",
"pl",
".",
"transport",
".",
"RetainPeer",
"(",
"pid",
",",
"ps",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"ps",
".",
"peer",
"=",
"p",
"\n",
"ps",
".",
"score",
"=",
"scorePeer",
"(",
"p",
")",
"\n",
"ps",
".",
"boundFinish",
"=",
"ps",
".",
"finish",
"\n",
"pl",
".",
"byIdentifier",
"[",
"pid",
".",
"Identifier",
"(",
")",
"]",
"=",
"ps",
"\n",
"pl",
".",
"byScore",
".",
"pushPeer",
"(",
"ps",
")",
"\n",
"pl",
".",
"internalNotifyStatusChanged",
"(",
"ps",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// retainPeer must be called with the mutex locked.
|
[
"retainPeer",
"must",
"be",
"called",
"with",
"the",
"mutex",
"locked",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/x/peerheap/list.go#L138-L156
|
10,907 |
yarpc/yarpc-go
|
peer/x/peerheap/list.go
|
releasePeer
|
func (pl *List) releasePeer(pid peer.Identifier) error {
ps, ok := pl.byIdentifier[pid.Identifier()]
if !ok {
return peer.ErrPeerRemoveNotInList(pid.Identifier())
}
if err := pl.byScore.validate(ps); err != nil {
return err
}
err := pl.transport.ReleasePeer(pid, ps)
delete(pl.byIdentifier, pid.Identifier())
pl.byScore.delete(ps.idx)
ps.list = nil
return err
}
|
go
|
func (pl *List) releasePeer(pid peer.Identifier) error {
ps, ok := pl.byIdentifier[pid.Identifier()]
if !ok {
return peer.ErrPeerRemoveNotInList(pid.Identifier())
}
if err := pl.byScore.validate(ps); err != nil {
return err
}
err := pl.transport.ReleasePeer(pid, ps)
delete(pl.byIdentifier, pid.Identifier())
pl.byScore.delete(ps.idx)
ps.list = nil
return err
}
|
[
"func",
"(",
"pl",
"*",
"List",
")",
"releasePeer",
"(",
"pid",
"peer",
".",
"Identifier",
")",
"error",
"{",
"ps",
",",
"ok",
":=",
"pl",
".",
"byIdentifier",
"[",
"pid",
".",
"Identifier",
"(",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"peer",
".",
"ErrPeerRemoveNotInList",
"(",
"pid",
".",
"Identifier",
"(",
")",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"pl",
".",
"byScore",
".",
"validate",
"(",
"ps",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
":=",
"pl",
".",
"transport",
".",
"ReleasePeer",
"(",
"pid",
",",
"ps",
")",
"\n",
"delete",
"(",
"pl",
".",
"byIdentifier",
",",
"pid",
".",
"Identifier",
"(",
")",
")",
"\n",
"pl",
".",
"byScore",
".",
"delete",
"(",
"ps",
".",
"idx",
")",
"\n",
"ps",
".",
"list",
"=",
"nil",
"\n",
"return",
"err",
"\n",
"}"
] |
// releasePeer must be called with the mutex locked.
|
[
"releasePeer",
"must",
"be",
"called",
"with",
"the",
"mutex",
"locked",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/x/peerheap/list.go#L159-L174
|
10,908 |
yarpc/yarpc-go
|
peer/x/peerheap/list.go
|
NotifyStatusChanged
|
func (pl *List) NotifyStatusChanged(pid peer.Identifier) {
pl.mu.Lock()
ps := pl.byIdentifier[pid.Identifier()]
pl.mu.Unlock()
ps.NotifyStatusChanged(pid)
}
|
go
|
func (pl *List) NotifyStatusChanged(pid peer.Identifier) {
pl.mu.Lock()
ps := pl.byIdentifier[pid.Identifier()]
pl.mu.Unlock()
ps.NotifyStatusChanged(pid)
}
|
[
"func",
"(",
"pl",
"*",
"List",
")",
"NotifyStatusChanged",
"(",
"pid",
"peer",
".",
"Identifier",
")",
"{",
"pl",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"ps",
":=",
"pl",
".",
"byIdentifier",
"[",
"pid",
".",
"Identifier",
"(",
")",
"]",
"\n",
"pl",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"ps",
".",
"NotifyStatusChanged",
"(",
"pid",
")",
"\n",
"}"
] |
// NotifyStatusChanged receives notifications when a peer becomes available,
// connected, unavailable, or when its pending request count changes.
// This method satisfies peer.Subscriber and is only used for tests, since
// the peer heap has a subscriber for each invividual peer.
|
[
"NotifyStatusChanged",
"receives",
"notifications",
"when",
"a",
"peer",
"becomes",
"available",
"connected",
"unavailable",
"or",
"when",
"its",
"pending",
"request",
"count",
"changes",
".",
"This",
"method",
"satisfies",
"peer",
".",
"Subscriber",
"and",
"is",
"only",
"used",
"for",
"tests",
"since",
"the",
"peer",
"heap",
"has",
"a",
"subscriber",
"for",
"each",
"invividual",
"peer",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/x/peerheap/list.go#L268-L273
|
10,909 |
yarpc/yarpc-go
|
internal/crossdock/client/echo/thrift.go
|
ThriftForTransport
|
func ThriftForTransport(t crossdock.T, transport string) {
t = createEchoT("thrift", transport, t)
fatals := crossdock.Fatals(t)
dispatcher := disp.CreateDispatcherForTransport(t, transport)
fatals.NoError(dispatcher.Start(), "could not start Dispatcher")
defer dispatcher.Stop()
client := echoclient.New(dispatcher.ClientConfig("yarpc-test"))
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
token := random.String(5)
pong, err := client.Echo(ctx, &echo.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)
}
|
go
|
func ThriftForTransport(t crossdock.T, transport string) {
t = createEchoT("thrift", transport, t)
fatals := crossdock.Fatals(t)
dispatcher := disp.CreateDispatcherForTransport(t, transport)
fatals.NoError(dispatcher.Start(), "could not start Dispatcher")
defer dispatcher.Stop()
client := echoclient.New(dispatcher.ClientConfig("yarpc-test"))
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
token := random.String(5)
pong, err := client.Echo(ctx, &echo.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)
}
|
[
"func",
"ThriftForTransport",
"(",
"t",
"crossdock",
".",
"T",
",",
"transport",
"string",
")",
"{",
"t",
"=",
"createEchoT",
"(",
"\"",
"\"",
",",
"transport",
",",
"t",
")",
"\n",
"fatals",
":=",
"crossdock",
".",
"Fatals",
"(",
"t",
")",
"\n\n",
"dispatcher",
":=",
"disp",
".",
"CreateDispatcherForTransport",
"(",
"t",
",",
"transport",
")",
"\n",
"fatals",
".",
"NoError",
"(",
"dispatcher",
".",
"Start",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"defer",
"dispatcher",
".",
"Stop",
"(",
")",
"\n\n",
"client",
":=",
"echoclient",
".",
"New",
"(",
"dispatcher",
".",
"ClientConfig",
"(",
"\"",
"\"",
")",
")",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"context",
".",
"Background",
"(",
")",
",",
"time",
".",
"Second",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"token",
":=",
"random",
".",
"String",
"(",
"5",
")",
"\n\n",
"pong",
",",
"err",
":=",
"client",
".",
"Echo",
"(",
"ctx",
",",
"&",
"echo",
".",
"Ping",
"{",
"Beep",
":",
"token",
"}",
")",
"\n\n",
"crossdock",
".",
"Fatals",
"(",
"t",
")",
".",
"NoError",
"(",
"err",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"crossdock",
".",
"Assert",
"(",
"t",
")",
".",
"Equal",
"(",
"token",
",",
"pong",
".",
"Boop",
",",
"\"",
"\"",
",",
"pong",
".",
"Boop",
")",
"\n",
"}"
] |
// ThriftForTransport implements the 'thrift' behavior for the given transport or behavior transport.
|
[
"ThriftForTransport",
"implements",
"the",
"thrift",
"behavior",
"for",
"the",
"given",
"transport",
"or",
"behavior",
"transport",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/client/echo/thrift.go#L40-L58
|
10,910 |
yarpc/yarpc-go
|
internal/crossdock/client/echo/raw.go
|
RawForTransport
|
func RawForTransport(t crossdock.T, transport string) {
t = createEchoT("raw", transport, t)
fatals := crossdock.Fatals(t)
dispatcher := disp.CreateDispatcherForTransport(t, transport)
fatals.NoError(dispatcher.Start(), "could not start Dispatcher")
defer dispatcher.Stop()
client := raw.New(dispatcher.ClientConfig("yarpc-test"))
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
token := random.Bytes(5)
resBody, err := client.Call(ctx, "echo/raw", token)
crossdock.Fatals(t).NoError(err, "call to echo/raw failed: %v", err)
crossdock.Assert(t).True(bytes.Equal(token, resBody), "server said: %v", resBody)
}
|
go
|
func RawForTransport(t crossdock.T, transport string) {
t = createEchoT("raw", transport, t)
fatals := crossdock.Fatals(t)
dispatcher := disp.CreateDispatcherForTransport(t, transport)
fatals.NoError(dispatcher.Start(), "could not start Dispatcher")
defer dispatcher.Stop()
client := raw.New(dispatcher.ClientConfig("yarpc-test"))
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
token := random.Bytes(5)
resBody, err := client.Call(ctx, "echo/raw", token)
crossdock.Fatals(t).NoError(err, "call to echo/raw failed: %v", err)
crossdock.Assert(t).True(bytes.Equal(token, resBody), "server said: %v", resBody)
}
|
[
"func",
"RawForTransport",
"(",
"t",
"crossdock",
".",
"T",
",",
"transport",
"string",
")",
"{",
"t",
"=",
"createEchoT",
"(",
"\"",
"\"",
",",
"transport",
",",
"t",
")",
"\n",
"fatals",
":=",
"crossdock",
".",
"Fatals",
"(",
"t",
")",
"\n\n",
"dispatcher",
":=",
"disp",
".",
"CreateDispatcherForTransport",
"(",
"t",
",",
"transport",
")",
"\n",
"fatals",
".",
"NoError",
"(",
"dispatcher",
".",
"Start",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"defer",
"dispatcher",
".",
"Stop",
"(",
")",
"\n\n",
"client",
":=",
"raw",
".",
"New",
"(",
"dispatcher",
".",
"ClientConfig",
"(",
"\"",
"\"",
")",
")",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"context",
".",
"Background",
"(",
")",
",",
"time",
".",
"Second",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"token",
":=",
"random",
".",
"Bytes",
"(",
"5",
")",
"\n",
"resBody",
",",
"err",
":=",
"client",
".",
"Call",
"(",
"ctx",
",",
"\"",
"\"",
",",
"token",
")",
"\n\n",
"crossdock",
".",
"Fatals",
"(",
"t",
")",
".",
"NoError",
"(",
"err",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"crossdock",
".",
"Assert",
"(",
"t",
")",
".",
"True",
"(",
"bytes",
".",
"Equal",
"(",
"token",
",",
"resBody",
")",
",",
"\"",
"\"",
",",
"resBody",
")",
"\n",
"}"
] |
// RawForTransport implements the 'raw' behavior for the given transport or behavior transport.
|
[
"RawForTransport",
"implements",
"the",
"raw",
"behavior",
"for",
"the",
"given",
"transport",
"or",
"behavior",
"transport",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/client/echo/raw.go#L40-L57
|
10,911 |
yarpc/yarpc-go
|
api/encoding/inbound_call.go
|
NewInboundCallWithOptions
|
func NewInboundCallWithOptions(ctx context.Context, opts ...InboundCallOption) (context.Context, *InboundCall) {
call := &InboundCall{}
for _, opt := range opts {
opt.apply(call)
}
return context.WithValue(ctx, inboundCallKey{}, call), call
}
|
go
|
func NewInboundCallWithOptions(ctx context.Context, opts ...InboundCallOption) (context.Context, *InboundCall) {
call := &InboundCall{}
for _, opt := range opts {
opt.apply(call)
}
return context.WithValue(ctx, inboundCallKey{}, call), call
}
|
[
"func",
"NewInboundCallWithOptions",
"(",
"ctx",
"context",
".",
"Context",
",",
"opts",
"...",
"InboundCallOption",
")",
"(",
"context",
".",
"Context",
",",
"*",
"InboundCall",
")",
"{",
"call",
":=",
"&",
"InboundCall",
"{",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
".",
"apply",
"(",
"call",
")",
"\n",
"}",
"\n",
"return",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"inboundCallKey",
"{",
"}",
",",
"call",
")",
",",
"call",
"\n",
"}"
] |
// NewInboundCallWithOptions builds a new InboundCall with the given context and
// options.
//
// A request context is returned and must be used in place of the original.
|
[
"NewInboundCallWithOptions",
"builds",
"a",
"new",
"InboundCall",
"with",
"the",
"given",
"context",
"and",
"options",
".",
"A",
"request",
"context",
"is",
"returned",
"and",
"must",
"be",
"used",
"in",
"place",
"of",
"the",
"original",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/inbound_call.go#L69-L75
|
10,912 |
yarpc/yarpc-go
|
api/encoding/inbound_call.go
|
getInboundCall
|
func getInboundCall(ctx context.Context) (*InboundCall, bool) {
call, ok := ctx.Value(inboundCallKey{}).(*InboundCall)
return call, ok
}
|
go
|
func getInboundCall(ctx context.Context) (*InboundCall, bool) {
call, ok := ctx.Value(inboundCallKey{}).(*InboundCall)
return call, ok
}
|
[
"func",
"getInboundCall",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"InboundCall",
",",
"bool",
")",
"{",
"call",
",",
"ok",
":=",
"ctx",
".",
"Value",
"(",
"inboundCallKey",
"{",
"}",
")",
".",
"(",
"*",
"InboundCall",
")",
"\n",
"return",
"call",
",",
"ok",
"\n",
"}"
] |
// getInboundCall returns the inbound call on this context or nil.
|
[
"getInboundCall",
"returns",
"the",
"inbound",
"call",
"on",
"this",
"context",
"or",
"nil",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/inbound_call.go#L78-L81
|
10,913 |
yarpc/yarpc-go
|
api/encoding/inbound_call.go
|
ReadFromRequest
|
func (ic *InboundCall) ReadFromRequest(req *transport.Request) error {
// TODO(abg): Maybe we should copy attributes over so that changes to the
// Request don't change the output.
ic.req = req
return nil
}
|
go
|
func (ic *InboundCall) ReadFromRequest(req *transport.Request) error {
// TODO(abg): Maybe we should copy attributes over so that changes to the
// Request don't change the output.
ic.req = req
return nil
}
|
[
"func",
"(",
"ic",
"*",
"InboundCall",
")",
"ReadFromRequest",
"(",
"req",
"*",
"transport",
".",
"Request",
")",
"error",
"{",
"// TODO(abg): Maybe we should copy attributes over so that changes to the",
"// Request don't change the output.",
"ic",
".",
"req",
"=",
"req",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ReadFromRequest reads information from the given request.
//
// This information may be queried on the context using functions like Caller,
// Service, Procedure, etc.
|
[
"ReadFromRequest",
"reads",
"information",
"from",
"the",
"given",
"request",
".",
"This",
"information",
"may",
"be",
"queried",
"on",
"the",
"context",
"using",
"functions",
"like",
"Caller",
"Service",
"Procedure",
"etc",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/inbound_call.go#L87-L92
|
10,914 |
yarpc/yarpc-go
|
api/encoding/inbound_call.go
|
ReadFromRequestMeta
|
func (ic *InboundCall) ReadFromRequestMeta(reqMeta *transport.RequestMeta) error {
ic.req = reqMeta.ToRequest()
return nil
}
|
go
|
func (ic *InboundCall) ReadFromRequestMeta(reqMeta *transport.RequestMeta) error {
ic.req = reqMeta.ToRequest()
return nil
}
|
[
"func",
"(",
"ic",
"*",
"InboundCall",
")",
"ReadFromRequestMeta",
"(",
"reqMeta",
"*",
"transport",
".",
"RequestMeta",
")",
"error",
"{",
"ic",
".",
"req",
"=",
"reqMeta",
".",
"ToRequest",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ReadFromRequestMeta reads information from the given request.
//
// This information may be queried on the context using functions like Caller,
// Service, Procedure, etc.
|
[
"ReadFromRequestMeta",
"reads",
"information",
"from",
"the",
"given",
"request",
".",
"This",
"information",
"may",
"be",
"queried",
"on",
"the",
"context",
"using",
"functions",
"like",
"Caller",
"Service",
"Procedure",
"etc",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/inbound_call.go#L98-L101
|
10,915 |
yarpc/yarpc-go
|
api/encoding/inbound_call.go
|
WriteToResponse
|
func (ic *InboundCall) WriteToResponse(resw transport.ResponseWriter) error {
var headers transport.Headers
for _, h := range ic.resHeaders {
headers = headers.With(h.k, h.v)
}
if headers.Len() > 0 {
resw.AddHeaders(headers)
}
return nil
}
|
go
|
func (ic *InboundCall) WriteToResponse(resw transport.ResponseWriter) error {
var headers transport.Headers
for _, h := range ic.resHeaders {
headers = headers.With(h.k, h.v)
}
if headers.Len() > 0 {
resw.AddHeaders(headers)
}
return nil
}
|
[
"func",
"(",
"ic",
"*",
"InboundCall",
")",
"WriteToResponse",
"(",
"resw",
"transport",
".",
"ResponseWriter",
")",
"error",
"{",
"var",
"headers",
"transport",
".",
"Headers",
"\n",
"for",
"_",
",",
"h",
":=",
"range",
"ic",
".",
"resHeaders",
"{",
"headers",
"=",
"headers",
".",
"With",
"(",
"h",
".",
"k",
",",
"h",
".",
"v",
")",
"\n",
"}",
"\n\n",
"if",
"headers",
".",
"Len",
"(",
")",
">",
"0",
"{",
"resw",
".",
"AddHeaders",
"(",
"headers",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// WriteToResponse writes response information from the InboundCall onto the
// given ResponseWriter.
//
// If used, this must be called before writing the response body to the
// ResponseWriter.
|
[
"WriteToResponse",
"writes",
"response",
"information",
"from",
"the",
"InboundCall",
"onto",
"the",
"given",
"ResponseWriter",
".",
"If",
"used",
"this",
"must",
"be",
"called",
"before",
"writing",
"the",
"response",
"body",
"to",
"the",
"ResponseWriter",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/inbound_call.go#L108-L119
|
10,916 |
yarpc/yarpc-go
|
encoding/thrift/internal/types.go
|
ExceptionType_Values
|
func ExceptionType_Values() []ExceptionType {
return []ExceptionType{
ExceptionTypeUnknown,
ExceptionTypeUnknownMethod,
ExceptionTypeInvalidMessageType,
ExceptionTypeWrongMethodName,
ExceptionTypeBadSequenceID,
ExceptionTypeMissingResult,
ExceptionTypeInternalError,
ExceptionTypeProtocolError,
ExceptionTypeInvalidTransform,
ExceptionTypeInvalidProtocol,
ExceptionTypeUnsupportedClientType,
}
}
|
go
|
func ExceptionType_Values() []ExceptionType {
return []ExceptionType{
ExceptionTypeUnknown,
ExceptionTypeUnknownMethod,
ExceptionTypeInvalidMessageType,
ExceptionTypeWrongMethodName,
ExceptionTypeBadSequenceID,
ExceptionTypeMissingResult,
ExceptionTypeInternalError,
ExceptionTypeProtocolError,
ExceptionTypeInvalidTransform,
ExceptionTypeInvalidProtocol,
ExceptionTypeUnsupportedClientType,
}
}
|
[
"func",
"ExceptionType_Values",
"(",
")",
"[",
"]",
"ExceptionType",
"{",
"return",
"[",
"]",
"ExceptionType",
"{",
"ExceptionTypeUnknown",
",",
"ExceptionTypeUnknownMethod",
",",
"ExceptionTypeInvalidMessageType",
",",
"ExceptionTypeWrongMethodName",
",",
"ExceptionTypeBadSequenceID",
",",
"ExceptionTypeMissingResult",
",",
"ExceptionTypeInternalError",
",",
"ExceptionTypeProtocolError",
",",
"ExceptionTypeInvalidTransform",
",",
"ExceptionTypeInvalidProtocol",
",",
"ExceptionTypeUnsupportedClientType",
",",
"}",
"\n",
"}"
] |
// ExceptionType_Values returns all recognized values of ExceptionType.
|
[
"ExceptionType_Values",
"returns",
"all",
"recognized",
"values",
"of",
"ExceptionType",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/internal/types.go#L55-L69
|
10,917 |
yarpc/yarpc-go
|
encoding/thrift/internal/types.go
|
MarshalText
|
func (v ExceptionType) MarshalText() ([]byte, error) {
switch int32(v) {
case 0:
return []byte("UNKNOWN"), nil
case 1:
return []byte("UNKNOWN_METHOD"), nil
case 2:
return []byte("INVALID_MESSAGE_TYPE"), nil
case 3:
return []byte("WRONG_METHOD_NAME"), nil
case 4:
return []byte("BAD_SEQUENCE_ID"), nil
case 5:
return []byte("MISSING_RESULT"), nil
case 6:
return []byte("INTERNAL_ERROR"), nil
case 7:
return []byte("PROTOCOL_ERROR"), nil
case 8:
return []byte("INVALID_TRANSFORM"), nil
case 9:
return []byte("INVALID_PROTOCOL"), nil
case 10:
return []byte("UNSUPPORTED_CLIENT_TYPE"), nil
}
return []byte(strconv.FormatInt(int64(v), 10)), nil
}
|
go
|
func (v ExceptionType) MarshalText() ([]byte, error) {
switch int32(v) {
case 0:
return []byte("UNKNOWN"), nil
case 1:
return []byte("UNKNOWN_METHOD"), nil
case 2:
return []byte("INVALID_MESSAGE_TYPE"), nil
case 3:
return []byte("WRONG_METHOD_NAME"), nil
case 4:
return []byte("BAD_SEQUENCE_ID"), nil
case 5:
return []byte("MISSING_RESULT"), nil
case 6:
return []byte("INTERNAL_ERROR"), nil
case 7:
return []byte("PROTOCOL_ERROR"), nil
case 8:
return []byte("INVALID_TRANSFORM"), nil
case 9:
return []byte("INVALID_PROTOCOL"), nil
case 10:
return []byte("UNSUPPORTED_CLIENT_TYPE"), nil
}
return []byte(strconv.FormatInt(int64(v), 10)), nil
}
|
[
"func",
"(",
"v",
"ExceptionType",
")",
"MarshalText",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"switch",
"int32",
"(",
"v",
")",
"{",
"case",
"0",
":",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"case",
"1",
":",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"case",
"2",
":",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"case",
"3",
":",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"case",
"4",
":",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"case",
"5",
":",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"case",
"6",
":",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"case",
"7",
":",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"case",
"8",
":",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"case",
"9",
":",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"case",
"10",
":",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"[",
"]",
"byte",
"(",
"strconv",
".",
"FormatInt",
"(",
"int64",
"(",
"v",
")",
",",
"10",
")",
")",
",",
"nil",
"\n",
"}"
] |
// MarshalText encodes ExceptionType to text.
//
// If the enum value is recognized, its name is returned. Otherwise,
// its integer value is returned.
//
// This implements the TextMarshaler interface.
|
[
"MarshalText",
"encodes",
"ExceptionType",
"to",
"text",
".",
"If",
"the",
"enum",
"value",
"is",
"recognized",
"its",
"name",
"is",
"returned",
".",
"Otherwise",
"its",
"integer",
"value",
"is",
"returned",
".",
"This",
"implements",
"the",
"TextMarshaler",
"interface",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/internal/types.go#L127-L153
|
10,918 |
yarpc/yarpc-go
|
encoding/thrift/internal/types.go
|
String
|
func (v ExceptionType) String() string {
w := int32(v)
switch w {
case 0:
return "UNKNOWN"
case 1:
return "UNKNOWN_METHOD"
case 2:
return "INVALID_MESSAGE_TYPE"
case 3:
return "WRONG_METHOD_NAME"
case 4:
return "BAD_SEQUENCE_ID"
case 5:
return "MISSING_RESULT"
case 6:
return "INTERNAL_ERROR"
case 7:
return "PROTOCOL_ERROR"
case 8:
return "INVALID_TRANSFORM"
case 9:
return "INVALID_PROTOCOL"
case 10:
return "UNSUPPORTED_CLIENT_TYPE"
}
return fmt.Sprintf("ExceptionType(%d)", w)
}
|
go
|
func (v ExceptionType) String() string {
w := int32(v)
switch w {
case 0:
return "UNKNOWN"
case 1:
return "UNKNOWN_METHOD"
case 2:
return "INVALID_MESSAGE_TYPE"
case 3:
return "WRONG_METHOD_NAME"
case 4:
return "BAD_SEQUENCE_ID"
case 5:
return "MISSING_RESULT"
case 6:
return "INTERNAL_ERROR"
case 7:
return "PROTOCOL_ERROR"
case 8:
return "INVALID_TRANSFORM"
case 9:
return "INVALID_PROTOCOL"
case 10:
return "UNSUPPORTED_CLIENT_TYPE"
}
return fmt.Sprintf("ExceptionType(%d)", w)
}
|
[
"func",
"(",
"v",
"ExceptionType",
")",
"String",
"(",
")",
"string",
"{",
"w",
":=",
"int32",
"(",
"v",
")",
"\n",
"switch",
"w",
"{",
"case",
"0",
":",
"return",
"\"",
"\"",
"\n",
"case",
"1",
":",
"return",
"\"",
"\"",
"\n",
"case",
"2",
":",
"return",
"\"",
"\"",
"\n",
"case",
"3",
":",
"return",
"\"",
"\"",
"\n",
"case",
"4",
":",
"return",
"\"",
"\"",
"\n",
"case",
"5",
":",
"return",
"\"",
"\"",
"\n",
"case",
"6",
":",
"return",
"\"",
"\"",
"\n",
"case",
"7",
":",
"return",
"\"",
"\"",
"\n",
"case",
"8",
":",
"return",
"\"",
"\"",
"\n",
"case",
"9",
":",
"return",
"\"",
"\"",
"\n",
"case",
"10",
":",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"w",
")",
"\n",
"}"
] |
// String returns a readable string representation of ExceptionType.
|
[
"String",
"returns",
"a",
"readable",
"string",
"representation",
"of",
"ExceptionType",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/internal/types.go#L221-L248
|
10,919 |
yarpc/yarpc-go
|
encoding/thrift/internal/types.go
|
String
|
func (v *TApplicationException) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
if v.Message != nil {
fields[i] = fmt.Sprintf("Message: %v", *(v.Message))
i++
}
if v.Type != nil {
fields[i] = fmt.Sprintf("Type: %v", *(v.Type))
i++
}
return fmt.Sprintf("TApplicationException{%v}", strings.Join(fields[:i], ", "))
}
|
go
|
func (v *TApplicationException) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
if v.Message != nil {
fields[i] = fmt.Sprintf("Message: %v", *(v.Message))
i++
}
if v.Type != nil {
fields[i] = fmt.Sprintf("Type: %v", *(v.Type))
i++
}
return fmt.Sprintf("TApplicationException{%v}", strings.Join(fields[:i], ", "))
}
|
[
"func",
"(",
"v",
"*",
"TApplicationException",
")",
"String",
"(",
")",
"string",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"var",
"fields",
"[",
"2",
"]",
"string",
"\n",
"i",
":=",
"0",
"\n",
"if",
"v",
".",
"Message",
"!=",
"nil",
"{",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"(",
"v",
".",
"Message",
")",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"if",
"v",
".",
"Type",
"!=",
"nil",
"{",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"(",
"v",
".",
"Type",
")",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"fields",
"[",
":",
"i",
"]",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// String returns a readable string representation of a TApplicationException
// struct.
|
[
"String",
"returns",
"a",
"readable",
"string",
"representation",
"of",
"a",
"TApplicationException",
"struct",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/internal/types.go#L434-L451
|
10,920 |
yarpc/yarpc-go
|
encoding/thrift/internal/types.go
|
Equals
|
func (v *TApplicationException) Equals(rhs *TApplicationException) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_String_EqualsPtr(v.Message, rhs.Message) {
return false
}
if !_ExceptionType_EqualsPtr(v.Type, rhs.Type) {
return false
}
return true
}
|
go
|
func (v *TApplicationException) Equals(rhs *TApplicationException) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_String_EqualsPtr(v.Message, rhs.Message) {
return false
}
if !_ExceptionType_EqualsPtr(v.Type, rhs.Type) {
return false
}
return true
}
|
[
"func",
"(",
"v",
"*",
"TApplicationException",
")",
"Equals",
"(",
"rhs",
"*",
"TApplicationException",
")",
"bool",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"rhs",
"==",
"nil",
"\n",
"}",
"else",
"if",
"rhs",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"_String_EqualsPtr",
"(",
"v",
".",
"Message",
",",
"rhs",
".",
"Message",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"_ExceptionType_EqualsPtr",
"(",
"v",
".",
"Type",
",",
"rhs",
".",
"Type",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Equals returns true if all the fields of this TApplicationException match the
// provided TApplicationException.
//
// This function performs a deep comparison.
|
[
"Equals",
"returns",
"true",
"if",
"all",
"the",
"fields",
"of",
"this",
"TApplicationException",
"match",
"the",
"provided",
"TApplicationException",
".",
"This",
"function",
"performs",
"a",
"deep",
"comparison",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/internal/types.go#L477-L491
|
10,921 |
yarpc/yarpc-go
|
encoding/thrift/internal/types.go
|
MarshalLogObject
|
func (v *TApplicationException) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Message != nil {
enc.AddString("message", *v.Message)
}
if v.Type != nil {
err = multierr.Append(err, enc.AddObject("type", *v.Type))
}
return err
}
|
go
|
func (v *TApplicationException) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Message != nil {
enc.AddString("message", *v.Message)
}
if v.Type != nil {
err = multierr.Append(err, enc.AddObject("type", *v.Type))
}
return err
}
|
[
"func",
"(",
"v",
"*",
"TApplicationException",
")",
"MarshalLogObject",
"(",
"enc",
"zapcore",
".",
"ObjectEncoder",
")",
"(",
"err",
"error",
")",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"v",
".",
"Message",
"!=",
"nil",
"{",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"*",
"v",
".",
"Message",
")",
"\n",
"}",
"\n",
"if",
"v",
".",
"Type",
"!=",
"nil",
"{",
"err",
"=",
"multierr",
".",
"Append",
"(",
"err",
",",
"enc",
".",
"AddObject",
"(",
"\"",
"\"",
",",
"*",
"v",
".",
"Type",
")",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of TApplicationException.
|
[
"MarshalLogObject",
"implements",
"zapcore",
".",
"ObjectMarshaler",
"enabling",
"fast",
"logging",
"of",
"TApplicationException",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/internal/types.go#L495-L506
|
10,922 |
yarpc/yarpc-go
|
encoding/thrift/inject.go
|
ClientBuilderOptions
|
func ClientBuilderOptions(_ transport.ClientConfig, f reflect.StructField) []ClientOption {
// Note that we don't use ClientConfig right now but since this code is
// called by generated code, we still accept it so that we can add logic
// based on it in the future without breaking the API (and thus, all
// generated code).
optionList := strings.Split(f.Tag.Get("thrift"), ",")
var opts []ClientOption
for _, opt := range optionList {
switch strings.ToLower(opt) {
case "multiplexed":
opts = append(opts, Multiplexed)
case "enveloped":
opts = append(opts, Enveloped)
default:
// Ignore unknown options
}
}
return opts
}
|
go
|
func ClientBuilderOptions(_ transport.ClientConfig, f reflect.StructField) []ClientOption {
// Note that we don't use ClientConfig right now but since this code is
// called by generated code, we still accept it so that we can add logic
// based on it in the future without breaking the API (and thus, all
// generated code).
optionList := strings.Split(f.Tag.Get("thrift"), ",")
var opts []ClientOption
for _, opt := range optionList {
switch strings.ToLower(opt) {
case "multiplexed":
opts = append(opts, Multiplexed)
case "enveloped":
opts = append(opts, Enveloped)
default:
// Ignore unknown options
}
}
return opts
}
|
[
"func",
"ClientBuilderOptions",
"(",
"_",
"transport",
".",
"ClientConfig",
",",
"f",
"reflect",
".",
"StructField",
")",
"[",
"]",
"ClientOption",
"{",
"// Note that we don't use ClientConfig right now but since this code is",
"// called by generated code, we still accept it so that we can add logic",
"// based on it in the future without breaking the API (and thus, all",
"// generated code).",
"optionList",
":=",
"strings",
".",
"Split",
"(",
"f",
".",
"Tag",
".",
"Get",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
")",
"\n",
"var",
"opts",
"[",
"]",
"ClientOption",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"optionList",
"{",
"switch",
"strings",
".",
"ToLower",
"(",
"opt",
")",
"{",
"case",
"\"",
"\"",
":",
"opts",
"=",
"append",
"(",
"opts",
",",
"Multiplexed",
")",
"\n",
"case",
"\"",
"\"",
":",
"opts",
"=",
"append",
"(",
"opts",
",",
"Enveloped",
")",
"\n",
"default",
":",
"// Ignore unknown options",
"}",
"\n",
"}",
"\n",
"return",
"opts",
"\n",
"}"
] |
// ClientBuilderOptions returns ClientOptions that InjectClients should use
// for a specific Thrift client given information about the field into which
// the client is being injected. This API will usually not be used directly by
// users but by the generated code.
|
[
"ClientBuilderOptions",
"returns",
"ClientOptions",
"that",
"InjectClients",
"should",
"use",
"for",
"a",
"specific",
"Thrift",
"client",
"given",
"information",
"about",
"the",
"field",
"into",
"which",
"the",
"client",
"is",
"being",
"injected",
".",
"This",
"API",
"will",
"usually",
"not",
"be",
"used",
"directly",
"by",
"users",
"but",
"by",
"the",
"generated",
"code",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/inject.go#L34-L53
|
10,923 |
yarpc/yarpc-go
|
x/debug/options.go
|
Logger
|
func Logger(logger *zap.Logger) Option {
return optionFunc(func(opts *options) {
opts.logger = logger
})
}
|
go
|
func Logger(logger *zap.Logger) Option {
return optionFunc(func(opts *options) {
opts.logger = logger
})
}
|
[
"func",
"Logger",
"(",
"logger",
"*",
"zap",
".",
"Logger",
")",
"Option",
"{",
"return",
"optionFunc",
"(",
"func",
"(",
"opts",
"*",
"options",
")",
"{",
"opts",
".",
"logger",
"=",
"logger",
"\n",
"}",
")",
"\n",
"}"
] |
// Logger specifies the logger that should be used to log.
// Default value is noop zap logger.
|
[
"Logger",
"specifies",
"the",
"logger",
"that",
"should",
"be",
"used",
"to",
"log",
".",
"Default",
"value",
"is",
"noop",
"zap",
"logger",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/x/debug/options.go#L40-L44
|
10,924 |
yarpc/yarpc-go
|
x/debug/options.go
|
tmpl
|
func tmpl(tmpl templateIface) Option {
return optionFunc(func(opts *options) {
opts.tmpl = tmpl
})
}
|
go
|
func tmpl(tmpl templateIface) Option {
return optionFunc(func(opts *options) {
opts.tmpl = tmpl
})
}
|
[
"func",
"tmpl",
"(",
"tmpl",
"templateIface",
")",
"Option",
"{",
"return",
"optionFunc",
"(",
"func",
"(",
"opts",
"*",
"options",
")",
"{",
"opts",
".",
"tmpl",
"=",
"tmpl",
"\n",
"}",
")",
"\n",
"}"
] |
// tmpl specifies the template to use.
// It is only used for testing.
|
[
"tmpl",
"specifies",
"the",
"template",
"to",
"use",
".",
"It",
"is",
"only",
"used",
"for",
"testing",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/x/debug/options.go#L48-L52
|
10,925 |
yarpc/yarpc-go
|
x/debug/options.go
|
applyOptions
|
func applyOptions(opts ...Option) options {
options := options{
logger: zap.NewNop(),
tmpl: _defaultTmpl,
}
for _, opt := range opts {
opt.apply(&options)
}
return options
}
|
go
|
func applyOptions(opts ...Option) options {
options := options{
logger: zap.NewNop(),
tmpl: _defaultTmpl,
}
for _, opt := range opts {
opt.apply(&options)
}
return options
}
|
[
"func",
"applyOptions",
"(",
"opts",
"...",
"Option",
")",
"options",
"{",
"options",
":=",
"options",
"{",
"logger",
":",
"zap",
".",
"NewNop",
"(",
")",
",",
"tmpl",
":",
"_defaultTmpl",
",",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
".",
"apply",
"(",
"&",
"options",
")",
"\n",
"}",
"\n",
"return",
"options",
"\n",
"}"
] |
// applyOptions creates new opts based on the given options.
|
[
"applyOptions",
"creates",
"new",
"opts",
"based",
"on",
"the",
"given",
"options",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/x/debug/options.go#L56-L65
|
10,926 |
yarpc/yarpc-go
|
api/middleware/outbound.go
|
ApplyUnaryOutbound
|
func ApplyUnaryOutbound(o transport.UnaryOutbound, f UnaryOutbound) transport.UnaryOutbound {
if f == nil {
return o
}
return unaryOutboundWithMiddleware{o: o, f: f}
}
|
go
|
func ApplyUnaryOutbound(o transport.UnaryOutbound, f UnaryOutbound) transport.UnaryOutbound {
if f == nil {
return o
}
return unaryOutboundWithMiddleware{o: o, f: f}
}
|
[
"func",
"ApplyUnaryOutbound",
"(",
"o",
"transport",
".",
"UnaryOutbound",
",",
"f",
"UnaryOutbound",
")",
"transport",
".",
"UnaryOutbound",
"{",
"if",
"f",
"==",
"nil",
"{",
"return",
"o",
"\n",
"}",
"\n",
"return",
"unaryOutboundWithMiddleware",
"{",
"o",
":",
"o",
",",
"f",
":",
"f",
"}",
"\n",
"}"
] |
// ApplyUnaryOutbound applies the given UnaryOutbound middleware to
// the given UnaryOutbound transport.
|
[
"ApplyUnaryOutbound",
"applies",
"the",
"given",
"UnaryOutbound",
"middleware",
"to",
"the",
"given",
"UnaryOutbound",
"transport",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/middleware/outbound.go#L52-L57
|
10,927 |
yarpc/yarpc-go
|
api/middleware/outbound.go
|
Call
|
func (f UnaryOutboundFunc) Call(ctx context.Context, request *transport.Request, out transport.UnaryOutbound) (*transport.Response, error) {
return f(ctx, request, out)
}
|
go
|
func (f UnaryOutboundFunc) Call(ctx context.Context, request *transport.Request, out transport.UnaryOutbound) (*transport.Response, error) {
return f(ctx, request, out)
}
|
[
"func",
"(",
"f",
"UnaryOutboundFunc",
")",
"Call",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"transport",
".",
"Request",
",",
"out",
"transport",
".",
"UnaryOutbound",
")",
"(",
"*",
"transport",
".",
"Response",
",",
"error",
")",
"{",
"return",
"f",
"(",
"ctx",
",",
"request",
",",
"out",
")",
"\n",
"}"
] |
// Call for UnaryOutboundFunc.
|
[
"Call",
"for",
"UnaryOutboundFunc",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/middleware/outbound.go#L63-L65
|
10,928 |
yarpc/yarpc-go
|
api/middleware/outbound.go
|
ApplyOnewayOutbound
|
func ApplyOnewayOutbound(o transport.OnewayOutbound, f OnewayOutbound) transport.OnewayOutbound {
if f == nil {
return o
}
return onewayOutboundWithMiddleware{o: o, f: f}
}
|
go
|
func ApplyOnewayOutbound(o transport.OnewayOutbound, f OnewayOutbound) transport.OnewayOutbound {
if f == nil {
return o
}
return onewayOutboundWithMiddleware{o: o, f: f}
}
|
[
"func",
"ApplyOnewayOutbound",
"(",
"o",
"transport",
".",
"OnewayOutbound",
",",
"f",
"OnewayOutbound",
")",
"transport",
".",
"OnewayOutbound",
"{",
"if",
"f",
"==",
"nil",
"{",
"return",
"o",
"\n",
"}",
"\n",
"return",
"onewayOutboundWithMiddleware",
"{",
"o",
":",
"o",
",",
"f",
":",
"f",
"}",
"\n",
"}"
] |
// ApplyOnewayOutbound applies the given OnewayOutbound middleware to
// the given OnewayOutbound transport.
|
[
"ApplyOnewayOutbound",
"applies",
"the",
"given",
"OnewayOutbound",
"middleware",
"to",
"the",
"given",
"OnewayOutbound",
"transport",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/middleware/outbound.go#L126-L131
|
10,929 |
yarpc/yarpc-go
|
api/middleware/outbound.go
|
CallOneway
|
func (f OnewayOutboundFunc) CallOneway(ctx context.Context, request *transport.Request, out transport.OnewayOutbound) (transport.Ack, error) {
return f(ctx, request, out)
}
|
go
|
func (f OnewayOutboundFunc) CallOneway(ctx context.Context, request *transport.Request, out transport.OnewayOutbound) (transport.Ack, error) {
return f(ctx, request, out)
}
|
[
"func",
"(",
"f",
"OnewayOutboundFunc",
")",
"CallOneway",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"transport",
".",
"Request",
",",
"out",
"transport",
".",
"OnewayOutbound",
")",
"(",
"transport",
".",
"Ack",
",",
"error",
")",
"{",
"return",
"f",
"(",
"ctx",
",",
"request",
",",
"out",
")",
"\n",
"}"
] |
// CallOneway for OnewayOutboundFunc.
|
[
"CallOneway",
"for",
"OnewayOutboundFunc",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/middleware/outbound.go#L137-L139
|
10,930 |
yarpc/yarpc-go
|
api/middleware/outbound.go
|
ApplyStreamOutbound
|
func ApplyStreamOutbound(o transport.StreamOutbound, f StreamOutbound) transport.StreamOutbound {
if f == nil {
return o
}
return streamOutboundWithMiddleware{o: o, f: f}
}
|
go
|
func ApplyStreamOutbound(o transport.StreamOutbound, f StreamOutbound) transport.StreamOutbound {
if f == nil {
return o
}
return streamOutboundWithMiddleware{o: o, f: f}
}
|
[
"func",
"ApplyStreamOutbound",
"(",
"o",
"transport",
".",
"StreamOutbound",
",",
"f",
"StreamOutbound",
")",
"transport",
".",
"StreamOutbound",
"{",
"if",
"f",
"==",
"nil",
"{",
"return",
"o",
"\n",
"}",
"\n",
"return",
"streamOutboundWithMiddleware",
"{",
"o",
":",
"o",
",",
"f",
":",
"f",
"}",
"\n",
"}"
] |
// ApplyStreamOutbound applies the given StreamOutbound middleware to
// the given StreamOutbound transport.
|
[
"ApplyStreamOutbound",
"applies",
"the",
"given",
"StreamOutbound",
"middleware",
"to",
"the",
"given",
"StreamOutbound",
"transport",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/middleware/outbound.go#L201-L206
|
10,931 |
yarpc/yarpc-go
|
api/middleware/outbound.go
|
CallStream
|
func (f StreamOutboundFunc) CallStream(ctx context.Context, request *transport.StreamRequest, out transport.StreamOutbound) (*transport.ClientStream, error) {
return f(ctx, request, out)
}
|
go
|
func (f StreamOutboundFunc) CallStream(ctx context.Context, request *transport.StreamRequest, out transport.StreamOutbound) (*transport.ClientStream, error) {
return f(ctx, request, out)
}
|
[
"func",
"(",
"f",
"StreamOutboundFunc",
")",
"CallStream",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"transport",
".",
"StreamRequest",
",",
"out",
"transport",
".",
"StreamOutbound",
")",
"(",
"*",
"transport",
".",
"ClientStream",
",",
"error",
")",
"{",
"return",
"f",
"(",
"ctx",
",",
"request",
",",
"out",
")",
"\n",
"}"
] |
// CallStream for StreamOutboundFunc.
|
[
"CallStream",
"for",
"StreamOutboundFunc",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/middleware/outbound.go#L212-L214
|
10,932 |
yarpc/yarpc-go
|
yarpcconfig/decode.go
|
fill
|
func (l *logging) fill(cfg *yarpc.Config) {
cfg.Logging.Levels.ApplicationError = (*zapcore.Level)(l.Levels.ApplicationError)
}
|
go
|
func (l *logging) fill(cfg *yarpc.Config) {
cfg.Logging.Levels.ApplicationError = (*zapcore.Level)(l.Levels.ApplicationError)
}
|
[
"func",
"(",
"l",
"*",
"logging",
")",
"fill",
"(",
"cfg",
"*",
"yarpc",
".",
"Config",
")",
"{",
"cfg",
".",
"Logging",
".",
"Levels",
".",
"ApplicationError",
"=",
"(",
"*",
"zapcore",
".",
"Level",
")",
"(",
"l",
".",
"Levels",
".",
"ApplicationError",
")",
"\n",
"}"
] |
// Fills values from this object into the provided YARPC config.
|
[
"Fills",
"values",
"from",
"this",
"object",
"into",
"the",
"provided",
"YARPC",
"config",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/decode.go#L48-L50
|
10,933 |
yarpc/yarpc-go
|
yarpcconfig/decode.go
|
Decode
|
func (l *zapLevel) Decode(into mapdecode.Into) error {
var s string
if err := into(&s); err != nil {
return fmt.Errorf("could not decode Zap log level: %v", err)
}
err := (*zapcore.Level)(l).UnmarshalText([]byte(s))
if err != nil {
return fmt.Errorf("could not decode Zap log level: %v", err)
}
return err
}
|
go
|
func (l *zapLevel) Decode(into mapdecode.Into) error {
var s string
if err := into(&s); err != nil {
return fmt.Errorf("could not decode Zap log level: %v", err)
}
err := (*zapcore.Level)(l).UnmarshalText([]byte(s))
if err != nil {
return fmt.Errorf("could not decode Zap log level: %v", err)
}
return err
}
|
[
"func",
"(",
"l",
"*",
"zapLevel",
")",
"Decode",
"(",
"into",
"mapdecode",
".",
"Into",
")",
"error",
"{",
"var",
"s",
"string",
"\n",
"if",
"err",
":=",
"into",
"(",
"&",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"(",
"*",
"zapcore",
".",
"Level",
")",
"(",
"l",
")",
".",
"UnmarshalText",
"(",
"[",
"]",
"byte",
"(",
"s",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// mapdecode doesn't suport encoding.TextMarhsaler by default so we have to do
// this manually.
|
[
"mapdecode",
"doesn",
"t",
"suport",
"encoding",
".",
"TextMarhsaler",
"by",
"default",
"so",
"we",
"have",
"to",
"do",
"this",
"manually",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/decode.go#L56-L67
|
10,934 |
yarpc/yarpc-go
|
internal/observability/extractor.go
|
NewNopContextExtractor
|
func NewNopContextExtractor() ContextExtractor {
return ContextExtractor(func(_ context.Context) zapcore.Field { return zap.Skip() })
}
|
go
|
func NewNopContextExtractor() ContextExtractor {
return ContextExtractor(func(_ context.Context) zapcore.Field { return zap.Skip() })
}
|
[
"func",
"NewNopContextExtractor",
"(",
")",
"ContextExtractor",
"{",
"return",
"ContextExtractor",
"(",
"func",
"(",
"_",
"context",
".",
"Context",
")",
"zapcore",
".",
"Field",
"{",
"return",
"zap",
".",
"Skip",
"(",
")",
"}",
")",
"\n",
"}"
] |
// NewNopContextExtractor returns a no-op ContextExtractor.
|
[
"NewNopContextExtractor",
"returns",
"a",
"no",
"-",
"op",
"ContextExtractor",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/observability/extractor.go#L35-L37
|
10,935 |
yarpc/yarpc-go
|
api/encoding/outbound_call.go
|
NewOutboundCall
|
func NewOutboundCall(options ...CallOption) *OutboundCall {
var call OutboundCall
for _, opt := range options {
opt.apply(&call)
}
return &call
}
|
go
|
func NewOutboundCall(options ...CallOption) *OutboundCall {
var call OutboundCall
for _, opt := range options {
opt.apply(&call)
}
return &call
}
|
[
"func",
"NewOutboundCall",
"(",
"options",
"...",
"CallOption",
")",
"*",
"OutboundCall",
"{",
"var",
"call",
"OutboundCall",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"options",
"{",
"opt",
".",
"apply",
"(",
"&",
"call",
")",
"\n",
"}",
"\n",
"return",
"&",
"call",
"\n",
"}"
] |
// NewOutboundCall constructs a new OutboundCall with the given options.
|
[
"NewOutboundCall",
"constructs",
"a",
"new",
"OutboundCall",
"with",
"the",
"given",
"options",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/outbound_call.go#L47-L53
|
10,936 |
yarpc/yarpc-go
|
api/encoding/outbound_call.go
|
NewStreamOutboundCall
|
func NewStreamOutboundCall(options ...CallOption) (*OutboundCall, error) {
call := NewOutboundCall(options...)
if call.responseHeaders != nil {
return nil, yarpcerrors.InvalidArgumentErrorf("response headers are not supported for streams")
}
return call, nil
}
|
go
|
func NewStreamOutboundCall(options ...CallOption) (*OutboundCall, error) {
call := NewOutboundCall(options...)
if call.responseHeaders != nil {
return nil, yarpcerrors.InvalidArgumentErrorf("response headers are not supported for streams")
}
return call, nil
}
|
[
"func",
"NewStreamOutboundCall",
"(",
"options",
"...",
"CallOption",
")",
"(",
"*",
"OutboundCall",
",",
"error",
")",
"{",
"call",
":=",
"NewOutboundCall",
"(",
"options",
"...",
")",
"\n",
"if",
"call",
".",
"responseHeaders",
"!=",
"nil",
"{",
"return",
"nil",
",",
"yarpcerrors",
".",
"InvalidArgumentErrorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"call",
",",
"nil",
"\n",
"}"
] |
// NewStreamOutboundCall constructs a new OutboundCall with the given
// options and enforces the OutboundCall is valid for streams.
|
[
"NewStreamOutboundCall",
"constructs",
"a",
"new",
"OutboundCall",
"with",
"the",
"given",
"options",
"and",
"enforces",
"the",
"OutboundCall",
"is",
"valid",
"for",
"streams",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/outbound_call.go#L57-L63
|
10,937 |
yarpc/yarpc-go
|
api/encoding/outbound_call.go
|
WriteToRequest
|
func (c *OutboundCall) WriteToRequest(ctx context.Context, req *transport.Request) (context.Context, error) {
for _, h := range c.headers {
req.Headers = req.Headers.With(h.k, h.v)
}
if c.shardKey != nil {
req.ShardKey = *c.shardKey
}
if c.routingKey != nil {
req.RoutingKey = *c.routingKey
}
if c.routingDelegate != nil {
req.RoutingDelegate = *c.routingDelegate
}
// NB(abg): context and error are unused for now but we want to leave room
// for CallOptions which can fail or modify the context.
return ctx, nil
}
|
go
|
func (c *OutboundCall) WriteToRequest(ctx context.Context, req *transport.Request) (context.Context, error) {
for _, h := range c.headers {
req.Headers = req.Headers.With(h.k, h.v)
}
if c.shardKey != nil {
req.ShardKey = *c.shardKey
}
if c.routingKey != nil {
req.RoutingKey = *c.routingKey
}
if c.routingDelegate != nil {
req.RoutingDelegate = *c.routingDelegate
}
// NB(abg): context and error are unused for now but we want to leave room
// for CallOptions which can fail or modify the context.
return ctx, nil
}
|
[
"func",
"(",
"c",
"*",
"OutboundCall",
")",
"WriteToRequest",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"transport",
".",
"Request",
")",
"(",
"context",
".",
"Context",
",",
"error",
")",
"{",
"for",
"_",
",",
"h",
":=",
"range",
"c",
".",
"headers",
"{",
"req",
".",
"Headers",
"=",
"req",
".",
"Headers",
".",
"With",
"(",
"h",
".",
"k",
",",
"h",
".",
"v",
")",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"shardKey",
"!=",
"nil",
"{",
"req",
".",
"ShardKey",
"=",
"*",
"c",
".",
"shardKey",
"\n",
"}",
"\n",
"if",
"c",
".",
"routingKey",
"!=",
"nil",
"{",
"req",
".",
"RoutingKey",
"=",
"*",
"c",
".",
"routingKey",
"\n",
"}",
"\n",
"if",
"c",
".",
"routingDelegate",
"!=",
"nil",
"{",
"req",
".",
"RoutingDelegate",
"=",
"*",
"c",
".",
"routingDelegate",
"\n",
"}",
"\n\n",
"// NB(abg): context and error are unused for now but we want to leave room",
"// for CallOptions which can fail or modify the context.",
"return",
"ctx",
",",
"nil",
"\n",
"}"
] |
// WriteToRequest fills the given request with request-specific options from
// the call.
//
// The context MAY be replaced by the OutboundCall.
|
[
"WriteToRequest",
"fills",
"the",
"given",
"request",
"with",
"request",
"-",
"specific",
"options",
"from",
"the",
"call",
".",
"The",
"context",
"MAY",
"be",
"replaced",
"by",
"the",
"OutboundCall",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/outbound_call.go#L69-L87
|
10,938 |
yarpc/yarpc-go
|
api/encoding/outbound_call.go
|
WriteToRequestMeta
|
func (c *OutboundCall) WriteToRequestMeta(ctx context.Context, reqMeta *transport.RequestMeta) (context.Context, error) {
for _, h := range c.headers {
reqMeta.Headers = reqMeta.Headers.With(h.k, h.v)
}
if c.shardKey != nil {
reqMeta.ShardKey = *c.shardKey
}
if c.routingKey != nil {
reqMeta.RoutingKey = *c.routingKey
}
if c.routingDelegate != nil {
reqMeta.RoutingDelegate = *c.routingDelegate
}
// NB(abg): context and error are unused for now but we want to leave room
// for CallOptions which can fail or modify the context.
return ctx, nil
}
|
go
|
func (c *OutboundCall) WriteToRequestMeta(ctx context.Context, reqMeta *transport.RequestMeta) (context.Context, error) {
for _, h := range c.headers {
reqMeta.Headers = reqMeta.Headers.With(h.k, h.v)
}
if c.shardKey != nil {
reqMeta.ShardKey = *c.shardKey
}
if c.routingKey != nil {
reqMeta.RoutingKey = *c.routingKey
}
if c.routingDelegate != nil {
reqMeta.RoutingDelegate = *c.routingDelegate
}
// NB(abg): context and error are unused for now but we want to leave room
// for CallOptions which can fail or modify the context.
return ctx, nil
}
|
[
"func",
"(",
"c",
"*",
"OutboundCall",
")",
"WriteToRequestMeta",
"(",
"ctx",
"context",
".",
"Context",
",",
"reqMeta",
"*",
"transport",
".",
"RequestMeta",
")",
"(",
"context",
".",
"Context",
",",
"error",
")",
"{",
"for",
"_",
",",
"h",
":=",
"range",
"c",
".",
"headers",
"{",
"reqMeta",
".",
"Headers",
"=",
"reqMeta",
".",
"Headers",
".",
"With",
"(",
"h",
".",
"k",
",",
"h",
".",
"v",
")",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"shardKey",
"!=",
"nil",
"{",
"reqMeta",
".",
"ShardKey",
"=",
"*",
"c",
".",
"shardKey",
"\n",
"}",
"\n",
"if",
"c",
".",
"routingKey",
"!=",
"nil",
"{",
"reqMeta",
".",
"RoutingKey",
"=",
"*",
"c",
".",
"routingKey",
"\n",
"}",
"\n",
"if",
"c",
".",
"routingDelegate",
"!=",
"nil",
"{",
"reqMeta",
".",
"RoutingDelegate",
"=",
"*",
"c",
".",
"routingDelegate",
"\n",
"}",
"\n\n",
"// NB(abg): context and error are unused for now but we want to leave room",
"// for CallOptions which can fail or modify the context.",
"return",
"ctx",
",",
"nil",
"\n",
"}"
] |
// WriteToRequestMeta fills the given request with request-specific options from
// the call.
//
// The context MAY be replaced by the OutboundCall.
|
[
"WriteToRequestMeta",
"fills",
"the",
"given",
"request",
"with",
"request",
"-",
"specific",
"options",
"from",
"the",
"call",
".",
"The",
"context",
"MAY",
"be",
"replaced",
"by",
"the",
"OutboundCall",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/outbound_call.go#L93-L111
|
10,939 |
yarpc/yarpc-go
|
api/encoding/outbound_call.go
|
ReadFromResponse
|
func (c *OutboundCall) ReadFromResponse(ctx context.Context, res *transport.Response) (context.Context, error) {
// We're not using ctx right now but we may in the future.
if c.responseHeaders != nil && res.Headers.Len() > 0 {
// We make a copy of the response headers because Headers.Items() must
// never be mutated.
headers := make(map[string]string, res.Headers.Len())
for k, v := range res.Headers.Items() {
headers[k] = v
}
*c.responseHeaders = headers
}
// NB(abg): context and error are unused for now but we want to leave room
// for CallOptions which can fail or modify the context.
return ctx, nil
}
|
go
|
func (c *OutboundCall) ReadFromResponse(ctx context.Context, res *transport.Response) (context.Context, error) {
// We're not using ctx right now but we may in the future.
if c.responseHeaders != nil && res.Headers.Len() > 0 {
// We make a copy of the response headers because Headers.Items() must
// never be mutated.
headers := make(map[string]string, res.Headers.Len())
for k, v := range res.Headers.Items() {
headers[k] = v
}
*c.responseHeaders = headers
}
// NB(abg): context and error are unused for now but we want to leave room
// for CallOptions which can fail or modify the context.
return ctx, nil
}
|
[
"func",
"(",
"c",
"*",
"OutboundCall",
")",
"ReadFromResponse",
"(",
"ctx",
"context",
".",
"Context",
",",
"res",
"*",
"transport",
".",
"Response",
")",
"(",
"context",
".",
"Context",
",",
"error",
")",
"{",
"// We're not using ctx right now but we may in the future.",
"if",
"c",
".",
"responseHeaders",
"!=",
"nil",
"&&",
"res",
".",
"Headers",
".",
"Len",
"(",
")",
">",
"0",
"{",
"// We make a copy of the response headers because Headers.Items() must",
"// never be mutated.",
"headers",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"res",
".",
"Headers",
".",
"Len",
"(",
")",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"res",
".",
"Headers",
".",
"Items",
"(",
")",
"{",
"headers",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"*",
"c",
".",
"responseHeaders",
"=",
"headers",
"\n",
"}",
"\n\n",
"// NB(abg): context and error are unused for now but we want to leave room",
"// for CallOptions which can fail or modify the context.",
"return",
"ctx",
",",
"nil",
"\n",
"}"
] |
// ReadFromResponse reads information from the response for this call.
//
// This should be called only if the request is unary.
|
[
"ReadFromResponse",
"reads",
"information",
"from",
"the",
"response",
"for",
"this",
"call",
".",
"This",
"should",
"be",
"called",
"only",
"if",
"the",
"request",
"is",
"unary",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/outbound_call.go#L116-L131
|
10,940 |
yarpc/yarpc-go
|
router.go
|
NewMapRouter
|
func NewMapRouter(defaultService string) MapRouter {
return MapRouter{
defaultService: defaultService,
serviceProcedures: make(map[serviceProcedure]transport.Procedure),
serviceProcedureEncodings: make(map[serviceProcedureEncoding]transport.Procedure),
supportedEncodings: make(map[serviceProcedure][]string),
serviceNames: map[string]struct{}{defaultService: {}},
}
}
|
go
|
func NewMapRouter(defaultService string) MapRouter {
return MapRouter{
defaultService: defaultService,
serviceProcedures: make(map[serviceProcedure]transport.Procedure),
serviceProcedureEncodings: make(map[serviceProcedureEncoding]transport.Procedure),
supportedEncodings: make(map[serviceProcedure][]string),
serviceNames: map[string]struct{}{defaultService: {}},
}
}
|
[
"func",
"NewMapRouter",
"(",
"defaultService",
"string",
")",
"MapRouter",
"{",
"return",
"MapRouter",
"{",
"defaultService",
":",
"defaultService",
",",
"serviceProcedures",
":",
"make",
"(",
"map",
"[",
"serviceProcedure",
"]",
"transport",
".",
"Procedure",
")",
",",
"serviceProcedureEncodings",
":",
"make",
"(",
"map",
"[",
"serviceProcedureEncoding",
"]",
"transport",
".",
"Procedure",
")",
",",
"supportedEncodings",
":",
"make",
"(",
"map",
"[",
"serviceProcedure",
"]",
"[",
"]",
"string",
")",
",",
"serviceNames",
":",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
"{",
"defaultService",
":",
"{",
"}",
"}",
",",
"}",
"\n",
"}"
] |
// NewMapRouter builds a new MapRouter that uses the given name as the
// default service name.
|
[
"NewMapRouter",
"builds",
"a",
"new",
"MapRouter",
"that",
"uses",
"the",
"given",
"name",
"as",
"the",
"default",
"service",
"name",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/router.go#L62-L70
|
10,941 |
yarpc/yarpc-go
|
router.go
|
Register
|
func (m MapRouter) Register(rs []transport.Procedure) {
for _, r := range rs {
if r.Service == "" {
r.Service = m.defaultService
}
if r.Name == "" {
panic("Expected procedure name not to be empty string in registration")
}
m.serviceNames[r.Service] = struct{}{}
sp := serviceProcedure{
service: r.Service,
procedure: r.Name,
}
if r.Encoding == "" {
// Protect against masking encoding-specific routes.
if _, ok := m.serviceProcedures[sp]; ok {
panic(fmt.Sprintf("Cannot register multiple handlers for every encoding for service %q and procedure %q", sp.service, sp.procedure))
}
if se, ok := m.supportedEncodings[sp]; ok {
panic(fmt.Sprintf("Cannot register a handler for every encoding for service %q and procedure %q when there are already handlers for %s", sp.service, sp.procedure, humanize.QuotedJoin(se, "and", "no encodings")))
}
// This supports wild card encodings (for backward compatibility,
// since type models like Thrift were not previously required to
// specify the encoding of every procedure).
m.serviceProcedures[sp] = r
continue
}
spe := serviceProcedureEncoding{
service: r.Service,
procedure: r.Name,
encoding: r.Encoding,
}
// Protect against overriding wildcards
if _, ok := m.serviceProcedures[sp]; ok {
panic(fmt.Sprintf("Cannot register a handler for both (service, procedure) on any * encoding and (service, procedure, encoding), specifically (%q, %q, %q)", r.Service, r.Name, r.Encoding))
}
// Route to individual handlers for unique combinations of service,
// procedure, and encoding. This shall henceforth be the
// recommended way for models to register procedures.
m.serviceProcedureEncodings[spe] = r
// Record supported encodings.
m.supportedEncodings[sp] = append(m.supportedEncodings[sp], string(r.Encoding))
}
}
|
go
|
func (m MapRouter) Register(rs []transport.Procedure) {
for _, r := range rs {
if r.Service == "" {
r.Service = m.defaultService
}
if r.Name == "" {
panic("Expected procedure name not to be empty string in registration")
}
m.serviceNames[r.Service] = struct{}{}
sp := serviceProcedure{
service: r.Service,
procedure: r.Name,
}
if r.Encoding == "" {
// Protect against masking encoding-specific routes.
if _, ok := m.serviceProcedures[sp]; ok {
panic(fmt.Sprintf("Cannot register multiple handlers for every encoding for service %q and procedure %q", sp.service, sp.procedure))
}
if se, ok := m.supportedEncodings[sp]; ok {
panic(fmt.Sprintf("Cannot register a handler for every encoding for service %q and procedure %q when there are already handlers for %s", sp.service, sp.procedure, humanize.QuotedJoin(se, "and", "no encodings")))
}
// This supports wild card encodings (for backward compatibility,
// since type models like Thrift were not previously required to
// specify the encoding of every procedure).
m.serviceProcedures[sp] = r
continue
}
spe := serviceProcedureEncoding{
service: r.Service,
procedure: r.Name,
encoding: r.Encoding,
}
// Protect against overriding wildcards
if _, ok := m.serviceProcedures[sp]; ok {
panic(fmt.Sprintf("Cannot register a handler for both (service, procedure) on any * encoding and (service, procedure, encoding), specifically (%q, %q, %q)", r.Service, r.Name, r.Encoding))
}
// Route to individual handlers for unique combinations of service,
// procedure, and encoding. This shall henceforth be the
// recommended way for models to register procedures.
m.serviceProcedureEncodings[spe] = r
// Record supported encodings.
m.supportedEncodings[sp] = append(m.supportedEncodings[sp], string(r.Encoding))
}
}
|
[
"func",
"(",
"m",
"MapRouter",
")",
"Register",
"(",
"rs",
"[",
"]",
"transport",
".",
"Procedure",
")",
"{",
"for",
"_",
",",
"r",
":=",
"range",
"rs",
"{",
"if",
"r",
".",
"Service",
"==",
"\"",
"\"",
"{",
"r",
".",
"Service",
"=",
"m",
".",
"defaultService",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Name",
"==",
"\"",
"\"",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"m",
".",
"serviceNames",
"[",
"r",
".",
"Service",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n\n",
"sp",
":=",
"serviceProcedure",
"{",
"service",
":",
"r",
".",
"Service",
",",
"procedure",
":",
"r",
".",
"Name",
",",
"}",
"\n\n",
"if",
"r",
".",
"Encoding",
"==",
"\"",
"\"",
"{",
"// Protect against masking encoding-specific routes.",
"if",
"_",
",",
"ok",
":=",
"m",
".",
"serviceProcedures",
"[",
"sp",
"]",
";",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"sp",
".",
"service",
",",
"sp",
".",
"procedure",
")",
")",
"\n",
"}",
"\n",
"if",
"se",
",",
"ok",
":=",
"m",
".",
"supportedEncodings",
"[",
"sp",
"]",
";",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"sp",
".",
"service",
",",
"sp",
".",
"procedure",
",",
"humanize",
".",
"QuotedJoin",
"(",
"se",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
")",
")",
"\n",
"}",
"\n",
"// This supports wild card encodings (for backward compatibility,",
"// since type models like Thrift were not previously required to",
"// specify the encoding of every procedure).",
"m",
".",
"serviceProcedures",
"[",
"sp",
"]",
"=",
"r",
"\n",
"continue",
"\n",
"}",
"\n\n",
"spe",
":=",
"serviceProcedureEncoding",
"{",
"service",
":",
"r",
".",
"Service",
",",
"procedure",
":",
"r",
".",
"Name",
",",
"encoding",
":",
"r",
".",
"Encoding",
",",
"}",
"\n\n",
"// Protect against overriding wildcards",
"if",
"_",
",",
"ok",
":=",
"m",
".",
"serviceProcedures",
"[",
"sp",
"]",
";",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"r",
".",
"Service",
",",
"r",
".",
"Name",
",",
"r",
".",
"Encoding",
")",
")",
"\n",
"}",
"\n",
"// Route to individual handlers for unique combinations of service,",
"// procedure, and encoding. This shall henceforth be the",
"// recommended way for models to register procedures.",
"m",
".",
"serviceProcedureEncodings",
"[",
"spe",
"]",
"=",
"r",
"\n",
"// Record supported encodings.",
"m",
".",
"supportedEncodings",
"[",
"sp",
"]",
"=",
"append",
"(",
"m",
".",
"supportedEncodings",
"[",
"sp",
"]",
",",
"string",
"(",
"r",
".",
"Encoding",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// Register registers the procedure with the MapRouter.
// If the procedure does not specify its service name, the procedure will
// inherit the default service name of the router.
// Procedures should specify their encoding, and multiple procedures with the
// same name and service name can exist if they handle different encodings.
// If a procedure does not specify an encoding, it can only support one handler.
// The router will select that handler regardless of the encoding.
|
[
"Register",
"registers",
"the",
"procedure",
"with",
"the",
"MapRouter",
".",
"If",
"the",
"procedure",
"does",
"not",
"specify",
"its",
"service",
"name",
"the",
"procedure",
"will",
"inherit",
"the",
"default",
"service",
"name",
"of",
"the",
"router",
".",
"Procedures",
"should",
"specify",
"their",
"encoding",
"and",
"multiple",
"procedures",
"with",
"the",
"same",
"name",
"and",
"service",
"name",
"can",
"exist",
"if",
"they",
"handle",
"different",
"encodings",
".",
"If",
"a",
"procedure",
"does",
"not",
"specify",
"an",
"encoding",
"it",
"can",
"only",
"support",
"one",
"handler",
".",
"The",
"router",
"will",
"select",
"that",
"handler",
"regardless",
"of",
"the",
"encoding",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/router.go#L79-L128
|
10,942 |
yarpc/yarpc-go
|
router.go
|
Procedures
|
func (m MapRouter) Procedures() []transport.Procedure {
procs := make([]transport.Procedure, 0, len(m.serviceProcedures)+len(m.serviceProcedureEncodings))
for _, v := range m.serviceProcedures {
procs = append(procs, v)
}
for _, v := range m.serviceProcedureEncodings {
procs = append(procs, v)
}
sort.Sort(sortableProcedures(procs))
return procs
}
|
go
|
func (m MapRouter) Procedures() []transport.Procedure {
procs := make([]transport.Procedure, 0, len(m.serviceProcedures)+len(m.serviceProcedureEncodings))
for _, v := range m.serviceProcedures {
procs = append(procs, v)
}
for _, v := range m.serviceProcedureEncodings {
procs = append(procs, v)
}
sort.Sort(sortableProcedures(procs))
return procs
}
|
[
"func",
"(",
"m",
"MapRouter",
")",
"Procedures",
"(",
")",
"[",
"]",
"transport",
".",
"Procedure",
"{",
"procs",
":=",
"make",
"(",
"[",
"]",
"transport",
".",
"Procedure",
",",
"0",
",",
"len",
"(",
"m",
".",
"serviceProcedures",
")",
"+",
"len",
"(",
"m",
".",
"serviceProcedureEncodings",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"m",
".",
"serviceProcedures",
"{",
"procs",
"=",
"append",
"(",
"procs",
",",
"v",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"m",
".",
"serviceProcedureEncodings",
"{",
"procs",
"=",
"append",
"(",
"procs",
",",
"v",
")",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"sortableProcedures",
"(",
"procs",
")",
")",
"\n",
"return",
"procs",
"\n",
"}"
] |
// Procedures returns a list procedures that
// have been registered so far.
|
[
"Procedures",
"returns",
"a",
"list",
"procedures",
"that",
"have",
"been",
"registered",
"so",
"far",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/router.go#L132-L142
|
10,943 |
yarpc/yarpc-go
|
router.go
|
getAvailableServiceNames
|
func getAvailableServiceNames(svcMap map[string]struct{}) string {
var serviceNames []string
for key := range svcMap {
serviceNames = append(serviceNames, strconv.Quote(key))
}
// Sort the string array to generate consistent result
sort.Strings(serviceNames)
return strings.Join(serviceNames, ", ")
}
|
go
|
func getAvailableServiceNames(svcMap map[string]struct{}) string {
var serviceNames []string
for key := range svcMap {
serviceNames = append(serviceNames, strconv.Quote(key))
}
// Sort the string array to generate consistent result
sort.Strings(serviceNames)
return strings.Join(serviceNames, ", ")
}
|
[
"func",
"getAvailableServiceNames",
"(",
"svcMap",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"string",
"{",
"var",
"serviceNames",
"[",
"]",
"string",
"\n",
"for",
"key",
":=",
"range",
"svcMap",
"{",
"serviceNames",
"=",
"append",
"(",
"serviceNames",
",",
"strconv",
".",
"Quote",
"(",
"key",
")",
")",
"\n",
"}",
"\n",
"// Sort the string array to generate consistent result",
"sort",
".",
"Strings",
"(",
"serviceNames",
")",
"\n",
"return",
"strings",
".",
"Join",
"(",
"serviceNames",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// Extract keys from service names map and return a formatted string
|
[
"Extract",
"keys",
"from",
"service",
"names",
"map",
"and",
"return",
"a",
"formatted",
"string"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/router.go#L209-L217
|
10,944 |
yarpc/yarpc-go
|
transport/tchannel/channel_inbound.go
|
NewInbound
|
func (t *ChannelTransport) NewInbound() *ChannelInbound {
return &ChannelInbound{
once: lifecycle.NewOnce(),
transport: t,
}
}
|
go
|
func (t *ChannelTransport) NewInbound() *ChannelInbound {
return &ChannelInbound{
once: lifecycle.NewOnce(),
transport: t,
}
}
|
[
"func",
"(",
"t",
"*",
"ChannelTransport",
")",
"NewInbound",
"(",
")",
"*",
"ChannelInbound",
"{",
"return",
"&",
"ChannelInbound",
"{",
"once",
":",
"lifecycle",
".",
"NewOnce",
"(",
")",
",",
"transport",
":",
"t",
",",
"}",
"\n",
"}"
] |
// NewInbound returns a new TChannel inbound backed by a shared TChannel
// transport. The returned ChannelInbound does not support peer.Chooser
// and uses TChannel's own internal load balancing peer selection.
// If you have a YARPC peer.Chooser, use the unqualified tchannel.NewInbound
// instead.
// There should only be one inbound for TChannel since all outbounds send the
// listening port over non-ephemeral connections so a service can deduplicate
// locally- and remotely-initiated persistent connections.
|
[
"NewInbound",
"returns",
"a",
"new",
"TChannel",
"inbound",
"backed",
"by",
"a",
"shared",
"TChannel",
"transport",
".",
"The",
"returned",
"ChannelInbound",
"does",
"not",
"support",
"peer",
".",
"Chooser",
"and",
"uses",
"TChannel",
"s",
"own",
"internal",
"load",
"balancing",
"peer",
"selection",
".",
"If",
"you",
"have",
"a",
"YARPC",
"peer",
".",
"Chooser",
"use",
"the",
"unqualified",
"tchannel",
".",
"NewInbound",
"instead",
".",
"There",
"should",
"only",
"be",
"one",
"inbound",
"for",
"TChannel",
"since",
"all",
"outbounds",
"send",
"the",
"listening",
"port",
"over",
"non",
"-",
"ephemeral",
"connections",
"so",
"a",
"service",
"can",
"deduplicate",
"locally",
"-",
"and",
"remotely",
"-",
"initiated",
"persistent",
"connections",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/tchannel/channel_inbound.go#L48-L53
|
10,945 |
yarpc/yarpc-go
|
serialize/serialize.go
|
ToBytes
|
func ToBytes(tracer opentracing.Tracer, spanContext opentracing.SpanContext, req *transport.Request) ([]byte, error) {
spanBytes, err := spanContextToBytes(tracer, spanContext)
if err != nil {
return nil, err
}
body, err := ioutil.ReadAll(req.Body)
if err != nil {
return nil, err
}
rpc := internal.RPC{
SpanContext: spanBytes,
CallerName: req.Caller,
ServiceName: req.Service,
Encoding: string(req.Encoding),
Procedure: req.Procedure,
Headers: req.Headers.Items(),
ShardKey: &req.ShardKey,
RoutingKey: &req.RoutingKey,
RoutingDelegate: &req.RoutingDelegate,
Body: body,
}
wireValue, err := rpc.ToWire()
if err != nil {
return nil, err
}
var writer bytes.Buffer
// use the first byte to version the serialization
if err := writer.WriteByte(version); err != nil {
return nil, err
}
err = protocol.Binary.Encode(wireValue, &writer)
return writer.Bytes(), err
}
|
go
|
func ToBytes(tracer opentracing.Tracer, spanContext opentracing.SpanContext, req *transport.Request) ([]byte, error) {
spanBytes, err := spanContextToBytes(tracer, spanContext)
if err != nil {
return nil, err
}
body, err := ioutil.ReadAll(req.Body)
if err != nil {
return nil, err
}
rpc := internal.RPC{
SpanContext: spanBytes,
CallerName: req.Caller,
ServiceName: req.Service,
Encoding: string(req.Encoding),
Procedure: req.Procedure,
Headers: req.Headers.Items(),
ShardKey: &req.ShardKey,
RoutingKey: &req.RoutingKey,
RoutingDelegate: &req.RoutingDelegate,
Body: body,
}
wireValue, err := rpc.ToWire()
if err != nil {
return nil, err
}
var writer bytes.Buffer
// use the first byte to version the serialization
if err := writer.WriteByte(version); err != nil {
return nil, err
}
err = protocol.Binary.Encode(wireValue, &writer)
return writer.Bytes(), err
}
|
[
"func",
"ToBytes",
"(",
"tracer",
"opentracing",
".",
"Tracer",
",",
"spanContext",
"opentracing",
".",
"SpanContext",
",",
"req",
"*",
"transport",
".",
"Request",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"spanBytes",
",",
"err",
":=",
"spanContextToBytes",
"(",
"tracer",
",",
"spanContext",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"body",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"req",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"rpc",
":=",
"internal",
".",
"RPC",
"{",
"SpanContext",
":",
"spanBytes",
",",
"CallerName",
":",
"req",
".",
"Caller",
",",
"ServiceName",
":",
"req",
".",
"Service",
",",
"Encoding",
":",
"string",
"(",
"req",
".",
"Encoding",
")",
",",
"Procedure",
":",
"req",
".",
"Procedure",
",",
"Headers",
":",
"req",
".",
"Headers",
".",
"Items",
"(",
")",
",",
"ShardKey",
":",
"&",
"req",
".",
"ShardKey",
",",
"RoutingKey",
":",
"&",
"req",
".",
"RoutingKey",
",",
"RoutingDelegate",
":",
"&",
"req",
".",
"RoutingDelegate",
",",
"Body",
":",
"body",
",",
"}",
"\n\n",
"wireValue",
",",
"err",
":=",
"rpc",
".",
"ToWire",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"writer",
"bytes",
".",
"Buffer",
"\n",
"// use the first byte to version the serialization",
"if",
"err",
":=",
"writer",
".",
"WriteByte",
"(",
"version",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"protocol",
".",
"Binary",
".",
"Encode",
"(",
"wireValue",
",",
"&",
"writer",
")",
"\n",
"return",
"writer",
".",
"Bytes",
"(",
")",
",",
"err",
"\n",
"}"
] |
// ToBytes encodes an opentracing.SpanContext and transport.Request into bytes
|
[
"ToBytes",
"encodes",
"an",
"opentracing",
".",
"SpanContext",
"and",
"transport",
".",
"Request",
"into",
"bytes"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/serialize.go#L42-L79
|
10,946 |
yarpc/yarpc-go
|
serialize/serialize.go
|
FromBytes
|
func FromBytes(tracer opentracing.Tracer, request []byte) (opentracing.SpanContext, *transport.Request, error) {
if len(request) <= 1 {
return nil, nil, errors.New("cannot deserialize empty request")
}
// check valid thrift serialization byte
if request[0] != 0 {
return nil, nil,
fmt.Errorf(
"unsupported YARPC serialization version '%v' found during deserialization",
request[0])
}
reader := bytes.NewReader(request[1:])
wireValue, err := protocol.Binary.Decode(reader, wire.TStruct)
if err != nil {
return nil, nil, err
}
var rpc internal.RPC
if err = rpc.FromWire(wireValue); err != nil {
return nil, nil, err
}
req := transport.Request{
Caller: rpc.CallerName,
Service: rpc.ServiceName,
Encoding: transport.Encoding(rpc.Encoding),
Procedure: rpc.Procedure,
Headers: transport.HeadersFromMap(rpc.Headers),
Body: bytes.NewBuffer(rpc.Body),
}
if rpc.ShardKey != nil {
req.ShardKey = *rpc.ShardKey
}
if rpc.RoutingKey != nil {
req.RoutingKey = *rpc.RoutingKey
}
if rpc.RoutingDelegate != nil {
req.RoutingDelegate = *rpc.RoutingDelegate
}
spanContext, err := spanContextFromBytes(tracer, rpc.SpanContext)
if err != nil {
return nil, nil, err
}
return spanContext, &req, nil
}
|
go
|
func FromBytes(tracer opentracing.Tracer, request []byte) (opentracing.SpanContext, *transport.Request, error) {
if len(request) <= 1 {
return nil, nil, errors.New("cannot deserialize empty request")
}
// check valid thrift serialization byte
if request[0] != 0 {
return nil, nil,
fmt.Errorf(
"unsupported YARPC serialization version '%v' found during deserialization",
request[0])
}
reader := bytes.NewReader(request[1:])
wireValue, err := protocol.Binary.Decode(reader, wire.TStruct)
if err != nil {
return nil, nil, err
}
var rpc internal.RPC
if err = rpc.FromWire(wireValue); err != nil {
return nil, nil, err
}
req := transport.Request{
Caller: rpc.CallerName,
Service: rpc.ServiceName,
Encoding: transport.Encoding(rpc.Encoding),
Procedure: rpc.Procedure,
Headers: transport.HeadersFromMap(rpc.Headers),
Body: bytes.NewBuffer(rpc.Body),
}
if rpc.ShardKey != nil {
req.ShardKey = *rpc.ShardKey
}
if rpc.RoutingKey != nil {
req.RoutingKey = *rpc.RoutingKey
}
if rpc.RoutingDelegate != nil {
req.RoutingDelegate = *rpc.RoutingDelegate
}
spanContext, err := spanContextFromBytes(tracer, rpc.SpanContext)
if err != nil {
return nil, nil, err
}
return spanContext, &req, nil
}
|
[
"func",
"FromBytes",
"(",
"tracer",
"opentracing",
".",
"Tracer",
",",
"request",
"[",
"]",
"byte",
")",
"(",
"opentracing",
".",
"SpanContext",
",",
"*",
"transport",
".",
"Request",
",",
"error",
")",
"{",
"if",
"len",
"(",
"request",
")",
"<=",
"1",
"{",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// check valid thrift serialization byte",
"if",
"request",
"[",
"0",
"]",
"!=",
"0",
"{",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"request",
"[",
"0",
"]",
")",
"\n",
"}",
"\n\n",
"reader",
":=",
"bytes",
".",
"NewReader",
"(",
"request",
"[",
"1",
":",
"]",
")",
"\n",
"wireValue",
",",
"err",
":=",
"protocol",
".",
"Binary",
".",
"Decode",
"(",
"reader",
",",
"wire",
".",
"TStruct",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"rpc",
"internal",
".",
"RPC",
"\n",
"if",
"err",
"=",
"rpc",
".",
"FromWire",
"(",
"wireValue",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
":=",
"transport",
".",
"Request",
"{",
"Caller",
":",
"rpc",
".",
"CallerName",
",",
"Service",
":",
"rpc",
".",
"ServiceName",
",",
"Encoding",
":",
"transport",
".",
"Encoding",
"(",
"rpc",
".",
"Encoding",
")",
",",
"Procedure",
":",
"rpc",
".",
"Procedure",
",",
"Headers",
":",
"transport",
".",
"HeadersFromMap",
"(",
"rpc",
".",
"Headers",
")",
",",
"Body",
":",
"bytes",
".",
"NewBuffer",
"(",
"rpc",
".",
"Body",
")",
",",
"}",
"\n\n",
"if",
"rpc",
".",
"ShardKey",
"!=",
"nil",
"{",
"req",
".",
"ShardKey",
"=",
"*",
"rpc",
".",
"ShardKey",
"\n",
"}",
"\n",
"if",
"rpc",
".",
"RoutingKey",
"!=",
"nil",
"{",
"req",
".",
"RoutingKey",
"=",
"*",
"rpc",
".",
"RoutingKey",
"\n",
"}",
"\n",
"if",
"rpc",
".",
"RoutingDelegate",
"!=",
"nil",
"{",
"req",
".",
"RoutingDelegate",
"=",
"*",
"rpc",
".",
"RoutingDelegate",
"\n",
"}",
"\n\n",
"spanContext",
",",
"err",
":=",
"spanContextFromBytes",
"(",
"tracer",
",",
"rpc",
".",
"SpanContext",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"spanContext",
",",
"&",
"req",
",",
"nil",
"\n",
"}"
] |
// FromBytes decodes bytes into a opentracing.SpanContext and transport.Request
|
[
"FromBytes",
"decodes",
"bytes",
"into",
"a",
"opentracing",
".",
"SpanContext",
"and",
"transport",
".",
"Request"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/serialize.go#L82-L131
|
10,947 |
yarpc/yarpc-go
|
api/transport/stream.go
|
NewServerStream
|
func NewServerStream(s Stream, options ...ServerStreamOption) (*ServerStream, error) {
if s == nil {
return nil, yarpcerrors.InvalidArgumentErrorf("non-nil stream is required")
}
return &ServerStream{stream: s}, nil
}
|
go
|
func NewServerStream(s Stream, options ...ServerStreamOption) (*ServerStream, error) {
if s == nil {
return nil, yarpcerrors.InvalidArgumentErrorf("non-nil stream is required")
}
return &ServerStream{stream: s}, nil
}
|
[
"func",
"NewServerStream",
"(",
"s",
"Stream",
",",
"options",
"...",
"ServerStreamOption",
")",
"(",
"*",
"ServerStream",
",",
"error",
")",
"{",
"if",
"s",
"==",
"nil",
"{",
"return",
"nil",
",",
"yarpcerrors",
".",
"InvalidArgumentErrorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"ServerStream",
"{",
"stream",
":",
"s",
"}",
",",
"nil",
"\n",
"}"
] |
// NewServerStream will create a new ServerStream.
|
[
"NewServerStream",
"will",
"create",
"a",
"new",
"ServerStream",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/transport/stream.go#L43-L48
|
10,948 |
yarpc/yarpc-go
|
api/transport/stream.go
|
SendMessage
|
func (s *ServerStream) SendMessage(ctx context.Context, msg *StreamMessage) error {
return s.stream.SendMessage(ctx, msg)
}
|
go
|
func (s *ServerStream) SendMessage(ctx context.Context, msg *StreamMessage) error {
return s.stream.SendMessage(ctx, msg)
}
|
[
"func",
"(",
"s",
"*",
"ServerStream",
")",
"SendMessage",
"(",
"ctx",
"context",
".",
"Context",
",",
"msg",
"*",
"StreamMessage",
")",
"error",
"{",
"return",
"s",
".",
"stream",
".",
"SendMessage",
"(",
"ctx",
",",
"msg",
")",
"\n",
"}"
] |
// SendMessage sends a request over the stream. It blocks until the message
// has been sent. In certain implementations, the timeout on the context
// will be used to timeout the request.
|
[
"SendMessage",
"sends",
"a",
"request",
"over",
"the",
"stream",
".",
"It",
"blocks",
"until",
"the",
"message",
"has",
"been",
"sent",
".",
"In",
"certain",
"implementations",
"the",
"timeout",
"on",
"the",
"context",
"will",
"be",
"used",
"to",
"timeout",
"the",
"request",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/transport/stream.go#L68-L70
|
10,949 |
yarpc/yarpc-go
|
api/transport/stream.go
|
ReceiveMessage
|
func (s *ServerStream) ReceiveMessage(ctx context.Context) (*StreamMessage, error) {
return s.stream.ReceiveMessage(ctx)
}
|
go
|
func (s *ServerStream) ReceiveMessage(ctx context.Context) (*StreamMessage, error) {
return s.stream.ReceiveMessage(ctx)
}
|
[
"func",
"(",
"s",
"*",
"ServerStream",
")",
"ReceiveMessage",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"StreamMessage",
",",
"error",
")",
"{",
"return",
"s",
".",
"stream",
".",
"ReceiveMessage",
"(",
"ctx",
")",
"\n",
"}"
] |
// ReceiveMessage blocks until a message is received from the connection. It
// returns an io.Reader with the contents of the message.
|
[
"ReceiveMessage",
"blocks",
"until",
"a",
"message",
"is",
"received",
"from",
"the",
"connection",
".",
"It",
"returns",
"an",
"io",
".",
"Reader",
"with",
"the",
"contents",
"of",
"the",
"message",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/transport/stream.go#L74-L76
|
10,950 |
yarpc/yarpc-go
|
api/transport/stream.go
|
NewClientStream
|
func NewClientStream(s StreamCloser, options ...ClientStreamOption) (*ClientStream, error) {
if s == nil {
return nil, yarpcerrors.InvalidArgumentErrorf("non-nil stream with close is required")
}
return &ClientStream{stream: s}, nil
}
|
go
|
func NewClientStream(s StreamCloser, options ...ClientStreamOption) (*ClientStream, error) {
if s == nil {
return nil, yarpcerrors.InvalidArgumentErrorf("non-nil stream with close is required")
}
return &ClientStream{stream: s}, nil
}
|
[
"func",
"NewClientStream",
"(",
"s",
"StreamCloser",
",",
"options",
"...",
"ClientStreamOption",
")",
"(",
"*",
"ClientStream",
",",
"error",
")",
"{",
"if",
"s",
"==",
"nil",
"{",
"return",
"nil",
",",
"yarpcerrors",
".",
"InvalidArgumentErrorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"ClientStream",
"{",
"stream",
":",
"s",
"}",
",",
"nil",
"\n",
"}"
] |
// NewClientStream will create a new ClientStream.
|
[
"NewClientStream",
"will",
"create",
"a",
"new",
"ClientStream",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/transport/stream.go#L85-L90
|
10,951 |
yarpc/yarpc-go
|
api/transport/stream.go
|
Close
|
func (s *ClientStream) Close(ctx context.Context) error {
return s.stream.Close(ctx)
}
|
go
|
func (s *ClientStream) Close(ctx context.Context) error {
return s.stream.Close(ctx)
}
|
[
"func",
"(",
"s",
"*",
"ClientStream",
")",
"Close",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"return",
"s",
".",
"stream",
".",
"Close",
"(",
"ctx",
")",
"\n",
"}"
] |
// Close will close the connection. It blocks until the server has
// acknowledged the close. In certain implementations, the timeout on the
// context will be used to timeout the request. If the server timed out the
// connection will be forced closed by the client.
|
[
"Close",
"will",
"close",
"the",
"connection",
".",
"It",
"blocks",
"until",
"the",
"server",
"has",
"acknowledged",
"the",
"close",
".",
"In",
"certain",
"implementations",
"the",
"timeout",
"on",
"the",
"context",
"will",
"be",
"used",
"to",
"timeout",
"the",
"request",
".",
"If",
"the",
"server",
"timed",
"out",
"the",
"connection",
"will",
"be",
"forced",
"closed",
"by",
"the",
"client",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/transport/stream.go#L124-L126
|
10,952 |
yarpc/yarpc-go
|
internal/examples/thrift-hello/hello/echo/types.go
|
String
|
func (v *EchoResponse) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
fields[i] = fmt.Sprintf("Message: %v", v.Message)
i++
fields[i] = fmt.Sprintf("Count: %v", v.Count)
i++
return fmt.Sprintf("EchoResponse{%v}", strings.Join(fields[:i], ", "))
}
|
go
|
func (v *EchoResponse) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
fields[i] = fmt.Sprintf("Message: %v", v.Message)
i++
fields[i] = fmt.Sprintf("Count: %v", v.Count)
i++
return fmt.Sprintf("EchoResponse{%v}", strings.Join(fields[:i], ", "))
}
|
[
"func",
"(",
"v",
"*",
"EchoResponse",
")",
"String",
"(",
")",
"string",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"var",
"fields",
"[",
"2",
"]",
"string",
"\n",
"i",
":=",
"0",
"\n",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"Message",
")",
"\n",
"i",
"++",
"\n",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"Count",
")",
"\n",
"i",
"++",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"fields",
"[",
":",
"i",
"]",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// String returns a readable string representation of a EchoResponse
// struct.
|
[
"String",
"returns",
"a",
"readable",
"string",
"representation",
"of",
"a",
"EchoResponse",
"struct",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-hello/hello/echo/types.go#L302-L315
|
10,953 |
yarpc/yarpc-go
|
internal/examples/thrift-hello/hello/echo/types.go
|
Equals
|
func (v *EchoResponse) Equals(rhs *EchoResponse) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !(v.Message == rhs.Message) {
return false
}
if !(v.Count == rhs.Count) {
return false
}
return true
}
|
go
|
func (v *EchoResponse) Equals(rhs *EchoResponse) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !(v.Message == rhs.Message) {
return false
}
if !(v.Count == rhs.Count) {
return false
}
return true
}
|
[
"func",
"(",
"v",
"*",
"EchoResponse",
")",
"Equals",
"(",
"rhs",
"*",
"EchoResponse",
")",
"bool",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"rhs",
"==",
"nil",
"\n",
"}",
"else",
"if",
"rhs",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"v",
".",
"Message",
"==",
"rhs",
".",
"Message",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"v",
".",
"Count",
"==",
"rhs",
".",
"Count",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Equals returns true if all the fields of this EchoResponse match the
// provided EchoResponse.
//
// This function performs a deep comparison.
|
[
"Equals",
"returns",
"true",
"if",
"all",
"the",
"fields",
"of",
"this",
"EchoResponse",
"match",
"the",
"provided",
"EchoResponse",
".",
"This",
"function",
"performs",
"a",
"deep",
"comparison",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-hello/hello/echo/types.go#L321-L335
|
10,954 |
yarpc/yarpc-go
|
internal/examples/thrift-hello/hello/echo/types.go
|
MarshalLogObject
|
func (v *EchoResponse) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
enc.AddString("message", v.Message)
enc.AddInt16("count", v.Count)
return err
}
|
go
|
func (v *EchoResponse) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
enc.AddString("message", v.Message)
enc.AddInt16("count", v.Count)
return err
}
|
[
"func",
"(",
"v",
"*",
"EchoResponse",
")",
"MarshalLogObject",
"(",
"enc",
"zapcore",
".",
"ObjectEncoder",
")",
"(",
"err",
"error",
")",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"v",
".",
"Message",
")",
"\n",
"enc",
".",
"AddInt16",
"(",
"\"",
"\"",
",",
"v",
".",
"Count",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of EchoResponse.
|
[
"MarshalLogObject",
"implements",
"zapcore",
".",
"ObjectMarshaler",
"enabling",
"fast",
"logging",
"of",
"EchoResponse",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-hello/hello/echo/types.go#L339-L346
|
10,955 |
yarpc/yarpc-go
|
encoding/protobuf/protoc-gen-yarpc-go/internal/lib/lib.go
|
fileDescriptorClosureVarName
|
func fileDescriptorClosureVarName(f *protoplugin.File) (string, error) {
name := f.GetName()
if name == "" {
return "", fmt.Errorf("could not create fileDescriptorClosureVarName: %s has no name", f)
}
// Use a sha256 of the filename instead of the filename to prevent any characters that are illegal
// as golang identifiers and to discourage external usage of this constant.
h := sha256.Sum256([]byte(name))
return fmt.Sprintf("yarpcFileDescriptorClosure%s", hex.EncodeToString(h[:8])), nil
}
|
go
|
func fileDescriptorClosureVarName(f *protoplugin.File) (string, error) {
name := f.GetName()
if name == "" {
return "", fmt.Errorf("could not create fileDescriptorClosureVarName: %s has no name", f)
}
// Use a sha256 of the filename instead of the filename to prevent any characters that are illegal
// as golang identifiers and to discourage external usage of this constant.
h := sha256.Sum256([]byte(name))
return fmt.Sprintf("yarpcFileDescriptorClosure%s", hex.EncodeToString(h[:8])), nil
}
|
[
"func",
"fileDescriptorClosureVarName",
"(",
"f",
"*",
"protoplugin",
".",
"File",
")",
"(",
"string",
",",
"error",
")",
"{",
"name",
":=",
"f",
".",
"GetName",
"(",
")",
"\n",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"f",
")",
"\n",
"}",
"\n\n",
"// Use a sha256 of the filename instead of the filename to prevent any characters that are illegal",
"// as golang identifiers and to discourage external usage of this constant.",
"h",
":=",
"sha256",
".",
"Sum256",
"(",
"[",
"]",
"byte",
"(",
"name",
")",
")",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"hex",
".",
"EncodeToString",
"(",
"h",
"[",
":",
"8",
"]",
")",
")",
",",
"nil",
"\n",
"}"
] |
// fileDescriptorClosureVarName is used to refer to a variable that contains a closure of all encoded
// file descriptors required to interpret a specific proto file. It is used in the yarpc codebase to
// attach reflection information to services.
|
[
"fileDescriptorClosureVarName",
"is",
"used",
"to",
"refer",
"to",
"a",
"variable",
"that",
"contains",
"a",
"closure",
"of",
"all",
"encoded",
"file",
"descriptors",
"required",
"to",
"interpret",
"a",
"specific",
"proto",
"file",
".",
"It",
"is",
"used",
"in",
"the",
"yarpc",
"codebase",
"to",
"attach",
"reflection",
"information",
"to",
"services",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protoc-gen-yarpc-go/internal/lib/lib.go#L667-L677
|
10,956 |
yarpc/yarpc-go
|
internal/grpcctx/grpcctx.go
|
Wrap
|
func (c *ContextWrapper) Wrap(ctx context.Context) context.Context {
return metadata.NewOutgoingContext(ctx, c.md)
}
|
go
|
func (c *ContextWrapper) Wrap(ctx context.Context) context.Context {
return metadata.NewOutgoingContext(ctx, c.md)
}
|
[
"func",
"(",
"c",
"*",
"ContextWrapper",
")",
"Wrap",
"(",
"ctx",
"context",
".",
"Context",
")",
"context",
".",
"Context",
"{",
"return",
"metadata",
".",
"NewOutgoingContext",
"(",
"ctx",
",",
"c",
".",
"md",
")",
"\n",
"}"
] |
// Wrap wraps the given context with the headers.
|
[
"Wrap",
"wraps",
"the",
"given",
"context",
"with",
"the",
"headers",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/grpcctx/grpcctx.go#L49-L51
|
10,957 |
yarpc/yarpc-go
|
internal/grpcctx/grpcctx.go
|
WithHeader
|
func (c *ContextWrapper) WithHeader(key, value string) *ContextWrapper {
return c.copyAndAdd(key, value)
}
|
go
|
func (c *ContextWrapper) WithHeader(key, value string) *ContextWrapper {
return c.copyAndAdd(key, value)
}
|
[
"func",
"(",
"c",
"*",
"ContextWrapper",
")",
"WithHeader",
"(",
"key",
",",
"value",
"string",
")",
"*",
"ContextWrapper",
"{",
"return",
"c",
".",
"copyAndAdd",
"(",
"key",
",",
"value",
")",
"\n",
"}"
] |
// WithHeader returns a new ContextWrapper with the given header.
|
[
"WithHeader",
"returns",
"a",
"new",
"ContextWrapper",
"with",
"the",
"given",
"header",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/grpcctx/grpcctx.go#L84-L86
|
10,958 |
yarpc/yarpc-go
|
internal/examples/thrift-oneway/sink/types.go
|
String
|
func (v *SinkRequest) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
fields[i] = fmt.Sprintf("Message: %v", v.Message)
i++
return fmt.Sprintf("SinkRequest{%v}", strings.Join(fields[:i], ", "))
}
|
go
|
func (v *SinkRequest) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
fields[i] = fmt.Sprintf("Message: %v", v.Message)
i++
return fmt.Sprintf("SinkRequest{%v}", strings.Join(fields[:i], ", "))
}
|
[
"func",
"(",
"v",
"*",
"SinkRequest",
")",
"String",
"(",
")",
"string",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"var",
"fields",
"[",
"1",
"]",
"string",
"\n",
"i",
":=",
"0",
"\n",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"Message",
")",
"\n",
"i",
"++",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"fields",
"[",
":",
"i",
"]",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// String returns a readable string representation of a SinkRequest
// struct.
|
[
"String",
"returns",
"a",
"readable",
"string",
"representation",
"of",
"a",
"SinkRequest",
"struct",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-oneway/sink/types.go#L115-L126
|
10,959 |
yarpc/yarpc-go
|
internal/examples/thrift-oneway/sink/types.go
|
Equals
|
func (v *SinkRequest) Equals(rhs *SinkRequest) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !(v.Message == rhs.Message) {
return false
}
return true
}
|
go
|
func (v *SinkRequest) Equals(rhs *SinkRequest) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !(v.Message == rhs.Message) {
return false
}
return true
}
|
[
"func",
"(",
"v",
"*",
"SinkRequest",
")",
"Equals",
"(",
"rhs",
"*",
"SinkRequest",
")",
"bool",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"rhs",
"==",
"nil",
"\n",
"}",
"else",
"if",
"rhs",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"v",
".",
"Message",
"==",
"rhs",
".",
"Message",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Equals returns true if all the fields of this SinkRequest match the
// provided SinkRequest.
//
// This function performs a deep comparison.
|
[
"Equals",
"returns",
"true",
"if",
"all",
"the",
"fields",
"of",
"this",
"SinkRequest",
"match",
"the",
"provided",
"SinkRequest",
".",
"This",
"function",
"performs",
"a",
"deep",
"comparison",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-oneway/sink/types.go#L132-L143
|
10,960 |
yarpc/yarpc-go
|
internal/examples/thrift-oneway/sink/types.go
|
MarshalLogObject
|
func (v *SinkRequest) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
enc.AddString("message", v.Message)
return err
}
|
go
|
func (v *SinkRequest) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
enc.AddString("message", v.Message)
return err
}
|
[
"func",
"(",
"v",
"*",
"SinkRequest",
")",
"MarshalLogObject",
"(",
"enc",
"zapcore",
".",
"ObjectEncoder",
")",
"(",
"err",
"error",
")",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"v",
".",
"Message",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SinkRequest.
|
[
"MarshalLogObject",
"implements",
"zapcore",
".",
"ObjectMarshaler",
"enabling",
"fast",
"logging",
"of",
"SinkRequest",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-oneway/sink/types.go#L147-L153
|
10,961 |
yarpc/yarpc-go
|
internal/crossdock/client/httpserver/behavior.go
|
Run
|
func Run(t crossdock.T) {
fatals := crossdock.Fatals(t)
server := t.Param(params.HTTPServer)
fatals.NotEmpty(server, "server is required")
httpTransport := http.NewTransport()
disp := yarpc.NewDispatcher(yarpc.Config{
Name: "client",
Outbounds: yarpc.Outbounds{
"yarpc-test": {
Unary: httpTransport.NewSingleOutbound(fmt.Sprintf("http://%s:8085", server)),
},
},
})
fatals.NoError(disp.Start(), "could not start Dispatcher")
defer disp.Stop()
runRaw(t, disp)
}
|
go
|
func Run(t crossdock.T) {
fatals := crossdock.Fatals(t)
server := t.Param(params.HTTPServer)
fatals.NotEmpty(server, "server is required")
httpTransport := http.NewTransport()
disp := yarpc.NewDispatcher(yarpc.Config{
Name: "client",
Outbounds: yarpc.Outbounds{
"yarpc-test": {
Unary: httpTransport.NewSingleOutbound(fmt.Sprintf("http://%s:8085", server)),
},
},
})
fatals.NoError(disp.Start(), "could not start Dispatcher")
defer disp.Stop()
runRaw(t, disp)
}
|
[
"func",
"Run",
"(",
"t",
"crossdock",
".",
"T",
")",
"{",
"fatals",
":=",
"crossdock",
".",
"Fatals",
"(",
"t",
")",
"\n\n",
"server",
":=",
"t",
".",
"Param",
"(",
"params",
".",
"HTTPServer",
")",
"\n",
"fatals",
".",
"NotEmpty",
"(",
"server",
",",
"\"",
"\"",
")",
"\n\n",
"httpTransport",
":=",
"http",
".",
"NewTransport",
"(",
")",
"\n",
"disp",
":=",
"yarpc",
".",
"NewDispatcher",
"(",
"yarpc",
".",
"Config",
"{",
"Name",
":",
"\"",
"\"",
",",
"Outbounds",
":",
"yarpc",
".",
"Outbounds",
"{",
"\"",
"\"",
":",
"{",
"Unary",
":",
"httpTransport",
".",
"NewSingleOutbound",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"server",
")",
")",
",",
"}",
",",
"}",
",",
"}",
")",
"\n\n",
"fatals",
".",
"NoError",
"(",
"disp",
".",
"Start",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"defer",
"disp",
".",
"Stop",
"(",
")",
"\n\n",
"runRaw",
"(",
"t",
",",
"disp",
")",
"\n",
"}"
] |
// Run exercise a yarpc client against a rigged httpserver.
|
[
"Run",
"exercise",
"a",
"yarpc",
"client",
"against",
"a",
"rigged",
"httpserver",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/client/httpserver/behavior.go#L37-L57
|
10,962 |
yarpc/yarpc-go
|
internal/crossdock/client/httpserver/behavior.go
|
runRaw
|
func runRaw(t crossdock.T, disp *yarpc.Dispatcher) {
assert := crossdock.Assert(t)
fatals := crossdock.Fatals(t)
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
client := raw.New(disp.ClientConfig("yarpc-test"))
_, err := client.Call(ctx, "handlertimeout/raw", nil)
fatals.Error(err, "expected an error")
if yarpcerrors.FromError(err).Code() == yarpcerrors.CodeInvalidArgument {
t.Skipf("handlertimeout/raw method not implemented: %v", err)
return
}
assert.Equal(yarpcerrors.CodeDeadlineExceeded, yarpcerrors.FromError(err).Code(), "is an error with code CodeDeadlineExceeded: %v", err)
}
|
go
|
func runRaw(t crossdock.T, disp *yarpc.Dispatcher) {
assert := crossdock.Assert(t)
fatals := crossdock.Fatals(t)
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
client := raw.New(disp.ClientConfig("yarpc-test"))
_, err := client.Call(ctx, "handlertimeout/raw", nil)
fatals.Error(err, "expected an error")
if yarpcerrors.FromError(err).Code() == yarpcerrors.CodeInvalidArgument {
t.Skipf("handlertimeout/raw method not implemented: %v", err)
return
}
assert.Equal(yarpcerrors.CodeDeadlineExceeded, yarpcerrors.FromError(err).Code(), "is an error with code CodeDeadlineExceeded: %v", err)
}
|
[
"func",
"runRaw",
"(",
"t",
"crossdock",
".",
"T",
",",
"disp",
"*",
"yarpc",
".",
"Dispatcher",
")",
"{",
"assert",
":=",
"crossdock",
".",
"Assert",
"(",
"t",
")",
"\n",
"fatals",
":=",
"crossdock",
".",
"Fatals",
"(",
"t",
")",
"\n\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"context",
".",
"Background",
"(",
")",
",",
"100",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"client",
":=",
"raw",
".",
"New",
"(",
"disp",
".",
"ClientConfig",
"(",
"\"",
"\"",
")",
")",
"\n",
"_",
",",
"err",
":=",
"client",
".",
"Call",
"(",
"ctx",
",",
"\"",
"\"",
",",
"nil",
")",
"\n",
"fatals",
".",
"Error",
"(",
"err",
",",
"\"",
"\"",
")",
"\n\n",
"if",
"yarpcerrors",
".",
"FromError",
"(",
"err",
")",
".",
"Code",
"(",
")",
"==",
"yarpcerrors",
".",
"CodeInvalidArgument",
"{",
"t",
".",
"Skipf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"assert",
".",
"Equal",
"(",
"yarpcerrors",
".",
"CodeDeadlineExceeded",
",",
"yarpcerrors",
".",
"FromError",
"(",
"err",
")",
".",
"Code",
"(",
")",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}"
] |
// runRaw tests if a yarpc client returns a remote timeout error behind the
// TimeoutError interface when a remote http handler returns a handler timeout.
|
[
"runRaw",
"tests",
"if",
"a",
"yarpc",
"client",
"returns",
"a",
"remote",
"timeout",
"error",
"behind",
"the",
"TimeoutError",
"interface",
"when",
"a",
"remote",
"http",
"handler",
"returns",
"a",
"handler",
"timeout",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/client/httpserver/behavior.go#L61-L78
|
10,963 |
yarpc/yarpc-go
|
encoding/protobuf/protobuf.go
|
BuildProcedures
|
func BuildProcedures(params BuildProceduresParams) []transport.Procedure {
procedures := make([]transport.Procedure, 0, 2*(len(params.UnaryHandlerParams)+len(params.OnewayHandlerParams)))
for _, unaryHandlerParams := range params.UnaryHandlerParams {
procedures = append(
procedures,
transport.Procedure{
Name: procedure.ToName(params.ServiceName, unaryHandlerParams.MethodName),
HandlerSpec: transport.NewUnaryHandlerSpec(unaryHandlerParams.Handler),
Encoding: Encoding,
},
transport.Procedure{
Name: procedure.ToName(params.ServiceName, unaryHandlerParams.MethodName),
HandlerSpec: transport.NewUnaryHandlerSpec(unaryHandlerParams.Handler),
Encoding: JSONEncoding,
},
)
}
for _, onewayHandlerParams := range params.OnewayHandlerParams {
procedures = append(
procedures,
transport.Procedure{
Name: procedure.ToName(params.ServiceName, onewayHandlerParams.MethodName),
HandlerSpec: transport.NewOnewayHandlerSpec(onewayHandlerParams.Handler),
Encoding: Encoding,
},
transport.Procedure{
Name: procedure.ToName(params.ServiceName, onewayHandlerParams.MethodName),
HandlerSpec: transport.NewOnewayHandlerSpec(onewayHandlerParams.Handler),
Encoding: JSONEncoding,
},
)
}
for _, streamHandlerParams := range params.StreamHandlerParams {
procedures = append(
procedures,
transport.Procedure{
Name: procedure.ToName(params.ServiceName, streamHandlerParams.MethodName),
HandlerSpec: transport.NewStreamHandlerSpec(streamHandlerParams.Handler),
Encoding: Encoding,
},
transport.Procedure{
Name: procedure.ToName(params.ServiceName, streamHandlerParams.MethodName),
HandlerSpec: transport.NewStreamHandlerSpec(streamHandlerParams.Handler),
Encoding: JSONEncoding,
},
)
}
return procedures
}
|
go
|
func BuildProcedures(params BuildProceduresParams) []transport.Procedure {
procedures := make([]transport.Procedure, 0, 2*(len(params.UnaryHandlerParams)+len(params.OnewayHandlerParams)))
for _, unaryHandlerParams := range params.UnaryHandlerParams {
procedures = append(
procedures,
transport.Procedure{
Name: procedure.ToName(params.ServiceName, unaryHandlerParams.MethodName),
HandlerSpec: transport.NewUnaryHandlerSpec(unaryHandlerParams.Handler),
Encoding: Encoding,
},
transport.Procedure{
Name: procedure.ToName(params.ServiceName, unaryHandlerParams.MethodName),
HandlerSpec: transport.NewUnaryHandlerSpec(unaryHandlerParams.Handler),
Encoding: JSONEncoding,
},
)
}
for _, onewayHandlerParams := range params.OnewayHandlerParams {
procedures = append(
procedures,
transport.Procedure{
Name: procedure.ToName(params.ServiceName, onewayHandlerParams.MethodName),
HandlerSpec: transport.NewOnewayHandlerSpec(onewayHandlerParams.Handler),
Encoding: Encoding,
},
transport.Procedure{
Name: procedure.ToName(params.ServiceName, onewayHandlerParams.MethodName),
HandlerSpec: transport.NewOnewayHandlerSpec(onewayHandlerParams.Handler),
Encoding: JSONEncoding,
},
)
}
for _, streamHandlerParams := range params.StreamHandlerParams {
procedures = append(
procedures,
transport.Procedure{
Name: procedure.ToName(params.ServiceName, streamHandlerParams.MethodName),
HandlerSpec: transport.NewStreamHandlerSpec(streamHandlerParams.Handler),
Encoding: Encoding,
},
transport.Procedure{
Name: procedure.ToName(params.ServiceName, streamHandlerParams.MethodName),
HandlerSpec: transport.NewStreamHandlerSpec(streamHandlerParams.Handler),
Encoding: JSONEncoding,
},
)
}
return procedures
}
|
[
"func",
"BuildProcedures",
"(",
"params",
"BuildProceduresParams",
")",
"[",
"]",
"transport",
".",
"Procedure",
"{",
"procedures",
":=",
"make",
"(",
"[",
"]",
"transport",
".",
"Procedure",
",",
"0",
",",
"2",
"*",
"(",
"len",
"(",
"params",
".",
"UnaryHandlerParams",
")",
"+",
"len",
"(",
"params",
".",
"OnewayHandlerParams",
")",
")",
")",
"\n",
"for",
"_",
",",
"unaryHandlerParams",
":=",
"range",
"params",
".",
"UnaryHandlerParams",
"{",
"procedures",
"=",
"append",
"(",
"procedures",
",",
"transport",
".",
"Procedure",
"{",
"Name",
":",
"procedure",
".",
"ToName",
"(",
"params",
".",
"ServiceName",
",",
"unaryHandlerParams",
".",
"MethodName",
")",
",",
"HandlerSpec",
":",
"transport",
".",
"NewUnaryHandlerSpec",
"(",
"unaryHandlerParams",
".",
"Handler",
")",
",",
"Encoding",
":",
"Encoding",
",",
"}",
",",
"transport",
".",
"Procedure",
"{",
"Name",
":",
"procedure",
".",
"ToName",
"(",
"params",
".",
"ServiceName",
",",
"unaryHandlerParams",
".",
"MethodName",
")",
",",
"HandlerSpec",
":",
"transport",
".",
"NewUnaryHandlerSpec",
"(",
"unaryHandlerParams",
".",
"Handler",
")",
",",
"Encoding",
":",
"JSONEncoding",
",",
"}",
",",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"onewayHandlerParams",
":=",
"range",
"params",
".",
"OnewayHandlerParams",
"{",
"procedures",
"=",
"append",
"(",
"procedures",
",",
"transport",
".",
"Procedure",
"{",
"Name",
":",
"procedure",
".",
"ToName",
"(",
"params",
".",
"ServiceName",
",",
"onewayHandlerParams",
".",
"MethodName",
")",
",",
"HandlerSpec",
":",
"transport",
".",
"NewOnewayHandlerSpec",
"(",
"onewayHandlerParams",
".",
"Handler",
")",
",",
"Encoding",
":",
"Encoding",
",",
"}",
",",
"transport",
".",
"Procedure",
"{",
"Name",
":",
"procedure",
".",
"ToName",
"(",
"params",
".",
"ServiceName",
",",
"onewayHandlerParams",
".",
"MethodName",
")",
",",
"HandlerSpec",
":",
"transport",
".",
"NewOnewayHandlerSpec",
"(",
"onewayHandlerParams",
".",
"Handler",
")",
",",
"Encoding",
":",
"JSONEncoding",
",",
"}",
",",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"streamHandlerParams",
":=",
"range",
"params",
".",
"StreamHandlerParams",
"{",
"procedures",
"=",
"append",
"(",
"procedures",
",",
"transport",
".",
"Procedure",
"{",
"Name",
":",
"procedure",
".",
"ToName",
"(",
"params",
".",
"ServiceName",
",",
"streamHandlerParams",
".",
"MethodName",
")",
",",
"HandlerSpec",
":",
"transport",
".",
"NewStreamHandlerSpec",
"(",
"streamHandlerParams",
".",
"Handler",
")",
",",
"Encoding",
":",
"Encoding",
",",
"}",
",",
"transport",
".",
"Procedure",
"{",
"Name",
":",
"procedure",
".",
"ToName",
"(",
"params",
".",
"ServiceName",
",",
"streamHandlerParams",
".",
"MethodName",
")",
",",
"HandlerSpec",
":",
"transport",
".",
"NewStreamHandlerSpec",
"(",
"streamHandlerParams",
".",
"Handler",
")",
",",
"Encoding",
":",
"JSONEncoding",
",",
"}",
",",
")",
"\n",
"}",
"\n",
"return",
"procedures",
"\n",
"}"
] |
// BuildProcedures builds the transport.Procedures.
|
[
"BuildProcedures",
"builds",
"the",
"transport",
".",
"Procedures",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protobuf.go#L77-L125
|
10,964 |
yarpc/yarpc-go
|
encoding/protobuf/protobuf.go
|
NewStreamClient
|
func NewStreamClient(params ClientParams) StreamClient {
return newClient(params.ServiceName, params.ClientConfig, params.Options...)
}
|
go
|
func NewStreamClient(params ClientParams) StreamClient {
return newClient(params.ServiceName, params.ClientConfig, params.Options...)
}
|
[
"func",
"NewStreamClient",
"(",
"params",
"ClientParams",
")",
"StreamClient",
"{",
"return",
"newClient",
"(",
"params",
".",
"ServiceName",
",",
"params",
".",
"ClientConfig",
",",
"params",
".",
"Options",
"...",
")",
"\n",
"}"
] |
// NewStreamClient creates a new stream client.
|
[
"NewStreamClient",
"creates",
"a",
"new",
"stream",
"client",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protobuf.go#L173-L175
|
10,965 |
yarpc/yarpc-go
|
encoding/protobuf/protobuf.go
|
NewUnaryHandler
|
func NewUnaryHandler(params UnaryHandlerParams) transport.UnaryHandler {
return newUnaryHandler(params.Handle, params.NewRequest)
}
|
go
|
func NewUnaryHandler(params UnaryHandlerParams) transport.UnaryHandler {
return newUnaryHandler(params.Handle, params.NewRequest)
}
|
[
"func",
"NewUnaryHandler",
"(",
"params",
"UnaryHandlerParams",
")",
"transport",
".",
"UnaryHandler",
"{",
"return",
"newUnaryHandler",
"(",
"params",
".",
"Handle",
",",
"params",
".",
"NewRequest",
")",
"\n",
"}"
] |
// NewUnaryHandler returns a new UnaryHandler.
|
[
"NewUnaryHandler",
"returns",
"a",
"new",
"UnaryHandler",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protobuf.go#L184-L186
|
10,966 |
yarpc/yarpc-go
|
encoding/protobuf/protobuf.go
|
NewOnewayHandler
|
func NewOnewayHandler(params OnewayHandlerParams) transport.OnewayHandler {
return newOnewayHandler(params.Handle, params.NewRequest)
}
|
go
|
func NewOnewayHandler(params OnewayHandlerParams) transport.OnewayHandler {
return newOnewayHandler(params.Handle, params.NewRequest)
}
|
[
"func",
"NewOnewayHandler",
"(",
"params",
"OnewayHandlerParams",
")",
"transport",
".",
"OnewayHandler",
"{",
"return",
"newOnewayHandler",
"(",
"params",
".",
"Handle",
",",
"params",
".",
"NewRequest",
")",
"\n",
"}"
] |
// NewOnewayHandler returns a new OnewayHandler.
|
[
"NewOnewayHandler",
"returns",
"a",
"new",
"OnewayHandler",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protobuf.go#L195-L197
|
10,967 |
yarpc/yarpc-go
|
encoding/protobuf/protobuf.go
|
ClientBuilderOptions
|
func ClientBuilderOptions(_ transport.ClientConfig, structField reflect.StructField) []ClientOption {
var opts []ClientOption
for _, opt := range uniqueLowercaseStrings(strings.Split(structField.Tag.Get("proto"), ",")) {
switch opt {
case "json":
opts = append(opts, UseJSON)
}
}
return opts
}
|
go
|
func ClientBuilderOptions(_ transport.ClientConfig, structField reflect.StructField) []ClientOption {
var opts []ClientOption
for _, opt := range uniqueLowercaseStrings(strings.Split(structField.Tag.Get("proto"), ",")) {
switch opt {
case "json":
opts = append(opts, UseJSON)
}
}
return opts
}
|
[
"func",
"ClientBuilderOptions",
"(",
"_",
"transport",
".",
"ClientConfig",
",",
"structField",
"reflect",
".",
"StructField",
")",
"[",
"]",
"ClientOption",
"{",
"var",
"opts",
"[",
"]",
"ClientOption",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"uniqueLowercaseStrings",
"(",
"strings",
".",
"Split",
"(",
"structField",
".",
"Tag",
".",
"Get",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
")",
")",
"{",
"switch",
"opt",
"{",
"case",
"\"",
"\"",
":",
"opts",
"=",
"append",
"(",
"opts",
",",
"UseJSON",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"opts",
"\n",
"}"
] |
// ClientBuilderOptions returns ClientOptions that yarpc.InjectClients should use for a
// specific client given information about the field into which the client is being injected.
|
[
"ClientBuilderOptions",
"returns",
"ClientOptions",
"that",
"yarpc",
".",
"InjectClients",
"should",
"use",
"for",
"a",
"specific",
"client",
"given",
"information",
"about",
"the",
"field",
"into",
"which",
"the",
"client",
"is",
"being",
"injected",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protobuf.go#L211-L220
|
10,968 |
yarpc/yarpc-go
|
encoding/protobuf/protobuf.go
|
CastError
|
func CastError(expectedType proto.Message, actualType proto.Message) error {
return yarpcerrors.Newf(yarpcerrors.CodeInternal, "expected proto.Message to have type %T but had type %T", expectedType, actualType)
}
|
go
|
func CastError(expectedType proto.Message, actualType proto.Message) error {
return yarpcerrors.Newf(yarpcerrors.CodeInternal, "expected proto.Message to have type %T but had type %T", expectedType, actualType)
}
|
[
"func",
"CastError",
"(",
"expectedType",
"proto",
".",
"Message",
",",
"actualType",
"proto",
".",
"Message",
")",
"error",
"{",
"return",
"yarpcerrors",
".",
"Newf",
"(",
"yarpcerrors",
".",
"CodeInternal",
",",
"\"",
"\"",
",",
"expectedType",
",",
"actualType",
")",
"\n",
"}"
] |
// CastError returns an error saying that generated code could not properly cast a proto.Message to it's expected type.
|
[
"CastError",
"returns",
"an",
"error",
"saying",
"that",
"generated",
"code",
"could",
"not",
"properly",
"cast",
"a",
"proto",
".",
"Message",
"to",
"it",
"s",
"expected",
"type",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protobuf.go#L223-L225
|
10,969 |
yarpc/yarpc-go
|
encoding/protobuf/protobuf.go
|
Receive
|
func (c *ClientStream) Receive(newMessage func() proto.Message, options ...yarpc.StreamOption) (proto.Message, error) {
return readFromStream(context.Background(), c.stream, newMessage)
}
|
go
|
func (c *ClientStream) Receive(newMessage func() proto.Message, options ...yarpc.StreamOption) (proto.Message, error) {
return readFromStream(context.Background(), c.stream, newMessage)
}
|
[
"func",
"(",
"c",
"*",
"ClientStream",
")",
"Receive",
"(",
"newMessage",
"func",
"(",
")",
"proto",
".",
"Message",
",",
"options",
"...",
"yarpc",
".",
"StreamOption",
")",
"(",
"proto",
".",
"Message",
",",
"error",
")",
"{",
"return",
"readFromStream",
"(",
"context",
".",
"Background",
"(",
")",
",",
"c",
".",
"stream",
",",
"newMessage",
")",
"\n",
"}"
] |
// Receive will receive a protobuf message from the client stream.
|
[
"Receive",
"will",
"receive",
"a",
"protobuf",
"message",
"from",
"the",
"client",
"stream",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protobuf.go#L258-L260
|
10,970 |
yarpc/yarpc-go
|
encoding/protobuf/protobuf.go
|
Send
|
func (c *ClientStream) Send(message proto.Message, options ...yarpc.StreamOption) error {
return writeToStream(context.Background(), c.stream, message)
}
|
go
|
func (c *ClientStream) Send(message proto.Message, options ...yarpc.StreamOption) error {
return writeToStream(context.Background(), c.stream, message)
}
|
[
"func",
"(",
"c",
"*",
"ClientStream",
")",
"Send",
"(",
"message",
"proto",
".",
"Message",
",",
"options",
"...",
"yarpc",
".",
"StreamOption",
")",
"error",
"{",
"return",
"writeToStream",
"(",
"context",
".",
"Background",
"(",
")",
",",
"c",
".",
"stream",
",",
"message",
")",
"\n",
"}"
] |
// Send will send a protobuf message to the client stream.
|
[
"Send",
"will",
"send",
"a",
"protobuf",
"message",
"to",
"the",
"client",
"stream",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protobuf.go#L263-L265
|
10,971 |
yarpc/yarpc-go
|
encoding/protobuf/protobuf.go
|
Close
|
func (c *ClientStream) Close(options ...yarpc.StreamOption) error {
return c.stream.Close(context.Background())
}
|
go
|
func (c *ClientStream) Close(options ...yarpc.StreamOption) error {
return c.stream.Close(context.Background())
}
|
[
"func",
"(",
"c",
"*",
"ClientStream",
")",
"Close",
"(",
"options",
"...",
"yarpc",
".",
"StreamOption",
")",
"error",
"{",
"return",
"c",
".",
"stream",
".",
"Close",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"}"
] |
// Close will close the protobuf stream.
|
[
"Close",
"will",
"close",
"the",
"protobuf",
"stream",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protobuf.go#L268-L270
|
10,972 |
yarpc/yarpc-go
|
encoding/protobuf/protobuf.go
|
Receive
|
func (s *ServerStream) Receive(newMessage func() proto.Message, options ...yarpc.StreamOption) (proto.Message, error) {
return readFromStream(context.Background(), s.stream, newMessage)
}
|
go
|
func (s *ServerStream) Receive(newMessage func() proto.Message, options ...yarpc.StreamOption) (proto.Message, error) {
return readFromStream(context.Background(), s.stream, newMessage)
}
|
[
"func",
"(",
"s",
"*",
"ServerStream",
")",
"Receive",
"(",
"newMessage",
"func",
"(",
")",
"proto",
".",
"Message",
",",
"options",
"...",
"yarpc",
".",
"StreamOption",
")",
"(",
"proto",
".",
"Message",
",",
"error",
")",
"{",
"return",
"readFromStream",
"(",
"context",
".",
"Background",
"(",
")",
",",
"s",
".",
"stream",
",",
"newMessage",
")",
"\n",
"}"
] |
// Receive will receive a protobuf message from the server stream.
|
[
"Receive",
"will",
"receive",
"a",
"protobuf",
"message",
"from",
"the",
"server",
"stream",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protobuf.go#L284-L286
|
10,973 |
yarpc/yarpc-go
|
encoding/protobuf/protobuf.go
|
Send
|
func (s *ServerStream) Send(message proto.Message, options ...yarpc.StreamOption) error {
return writeToStream(context.Background(), s.stream, message)
}
|
go
|
func (s *ServerStream) Send(message proto.Message, options ...yarpc.StreamOption) error {
return writeToStream(context.Background(), s.stream, message)
}
|
[
"func",
"(",
"s",
"*",
"ServerStream",
")",
"Send",
"(",
"message",
"proto",
".",
"Message",
",",
"options",
"...",
"yarpc",
".",
"StreamOption",
")",
"error",
"{",
"return",
"writeToStream",
"(",
"context",
".",
"Background",
"(",
")",
",",
"s",
".",
"stream",
",",
"message",
")",
"\n",
"}"
] |
// Send will send a protobuf message to the server stream.
|
[
"Send",
"will",
"send",
"a",
"protobuf",
"message",
"to",
"the",
"server",
"stream",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/protobuf.go#L289-L291
|
10,974 |
yarpc/yarpc-go
|
internal/whitespace/expand.go
|
Expand
|
func Expand(s string) string {
lines := strings.Split(s, "\n")
for i, l := range lines {
lines[i] = expandLine(l)
}
return strings.Join(lines, "\n")
}
|
go
|
func Expand(s string) string {
lines := strings.Split(s, "\n")
for i, l := range lines {
lines[i] = expandLine(l)
}
return strings.Join(lines, "\n")
}
|
[
"func",
"Expand",
"(",
"s",
"string",
")",
"string",
"{",
"lines",
":=",
"strings",
".",
"Split",
"(",
"s",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"for",
"i",
",",
"l",
":=",
"range",
"lines",
"{",
"lines",
"[",
"i",
"]",
"=",
"expandLine",
"(",
"l",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"lines",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}"
] |
// Expand converts leading tabs to two spaces, such that YAML accepts the whole
// block.
|
[
"Expand",
"converts",
"leading",
"tabs",
"to",
"two",
"spaces",
"such",
"that",
"YAML",
"accepts",
"the",
"whole",
"block",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/whitespace/expand.go#L27-L33
|
10,975 |
yarpc/yarpc-go
|
internal/crossdock/crossdockpb/crossdock.pb.yarpc.go
|
NewEchoYARPCClient
|
func NewEchoYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) EchoYARPCClient {
return &_EchoYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.crossdock.Echo",
ClientConfig: clientConfig,
Options: options,
},
)}
}
|
go
|
func NewEchoYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) EchoYARPCClient {
return &_EchoYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.crossdock.Echo",
ClientConfig: clientConfig,
Options: options,
},
)}
}
|
[
"func",
"NewEchoYARPCClient",
"(",
"clientConfig",
"transport",
".",
"ClientConfig",
",",
"options",
"...",
"protobuf",
".",
"ClientOption",
")",
"EchoYARPCClient",
"{",
"return",
"&",
"_EchoYARPCCaller",
"{",
"protobuf",
".",
"NewStreamClient",
"(",
"protobuf",
".",
"ClientParams",
"{",
"ServiceName",
":",
"\"",
"\"",
",",
"ClientConfig",
":",
"clientConfig",
",",
"Options",
":",
"options",
",",
"}",
",",
")",
"}",
"\n",
"}"
] |
// NewEchoYARPCClient builds a new YARPC client for the Echo service.
|
[
"NewEchoYARPCClient",
"builds",
"a",
"new",
"YARPC",
"client",
"for",
"the",
"Echo",
"service",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/crossdockpb/crossdock.pb.yarpc.go#L49-L57
|
10,976 |
yarpc/yarpc-go
|
internal/crossdock/crossdockpb/crossdock.pb.yarpc.go
|
BuildEchoYARPCProcedures
|
func BuildEchoYARPCProcedures(server EchoYARPCServer) []transport.Procedure {
handler := &_EchoYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.crossdock.Echo",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{
{
MethodName: "Echo",
Handler: protobuf.NewUnaryHandler(
protobuf.UnaryHandlerParams{
Handle: handler.Echo,
NewRequest: newEchoServiceEchoYARPCRequest,
},
),
},
},
OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{},
StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{},
},
)
}
|
go
|
func BuildEchoYARPCProcedures(server EchoYARPCServer) []transport.Procedure {
handler := &_EchoYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.crossdock.Echo",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{
{
MethodName: "Echo",
Handler: protobuf.NewUnaryHandler(
protobuf.UnaryHandlerParams{
Handle: handler.Echo,
NewRequest: newEchoServiceEchoYARPCRequest,
},
),
},
},
OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{},
StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{},
},
)
}
|
[
"func",
"BuildEchoYARPCProcedures",
"(",
"server",
"EchoYARPCServer",
")",
"[",
"]",
"transport",
".",
"Procedure",
"{",
"handler",
":=",
"&",
"_EchoYARPCHandler",
"{",
"server",
"}",
"\n",
"return",
"protobuf",
".",
"BuildProcedures",
"(",
"protobuf",
".",
"BuildProceduresParams",
"{",
"ServiceName",
":",
"\"",
"\"",
",",
"UnaryHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresUnaryHandlerParams",
"{",
"{",
"MethodName",
":",
"\"",
"\"",
",",
"Handler",
":",
"protobuf",
".",
"NewUnaryHandler",
"(",
"protobuf",
".",
"UnaryHandlerParams",
"{",
"Handle",
":",
"handler",
".",
"Echo",
",",
"NewRequest",
":",
"newEchoServiceEchoYARPCRequest",
",",
"}",
",",
")",
",",
"}",
",",
"}",
",",
"OnewayHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresOnewayHandlerParams",
"{",
"}",
",",
"StreamHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresStreamHandlerParams",
"{",
"}",
",",
"}",
",",
")",
"\n",
"}"
] |
// BuildEchoYARPCProcedures prepares an implementation of the Echo service for YARPC registration.
|
[
"BuildEchoYARPCProcedures",
"prepares",
"an",
"implementation",
"of",
"the",
"Echo",
"service",
"for",
"YARPC",
"registration",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/crossdockpb/crossdock.pb.yarpc.go#L65-L85
|
10,977 |
yarpc/yarpc-go
|
internal/crossdock/crossdockpb/crossdock.pb.yarpc.go
|
NewOnewayYARPCClient
|
func NewOnewayYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) OnewayYARPCClient {
return &_OnewayYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.crossdock.Oneway",
ClientConfig: clientConfig,
Options: options,
},
)}
}
|
go
|
func NewOnewayYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) OnewayYARPCClient {
return &_OnewayYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.crossdock.Oneway",
ClientConfig: clientConfig,
Options: options,
},
)}
}
|
[
"func",
"NewOnewayYARPCClient",
"(",
"clientConfig",
"transport",
".",
"ClientConfig",
",",
"options",
"...",
"protobuf",
".",
"ClientOption",
")",
"OnewayYARPCClient",
"{",
"return",
"&",
"_OnewayYARPCCaller",
"{",
"protobuf",
".",
"NewStreamClient",
"(",
"protobuf",
".",
"ClientParams",
"{",
"ServiceName",
":",
"\"",
"\"",
",",
"ClientConfig",
":",
"clientConfig",
",",
"Options",
":",
"options",
",",
"}",
",",
")",
"}",
"\n",
"}"
] |
// NewOnewayYARPCClient builds a new YARPC client for the Oneway service.
|
[
"NewOnewayYARPCClient",
"builds",
"a",
"new",
"YARPC",
"client",
"for",
"the",
"Oneway",
"service",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/crossdockpb/crossdock.pb.yarpc.go#L222-L230
|
10,978 |
yarpc/yarpc-go
|
internal/crossdock/crossdockpb/crossdock.pb.yarpc.go
|
BuildOnewayYARPCProcedures
|
func BuildOnewayYARPCProcedures(server OnewayYARPCServer) []transport.Procedure {
handler := &_OnewayYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.crossdock.Oneway",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{},
OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{
{
MethodName: "Echo",
Handler: protobuf.NewOnewayHandler(
protobuf.OnewayHandlerParams{
Handle: handler.Echo,
NewRequest: newOnewayServiceEchoYARPCRequest,
},
),
},
},
StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{},
},
)
}
|
go
|
func BuildOnewayYARPCProcedures(server OnewayYARPCServer) []transport.Procedure {
handler := &_OnewayYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.crossdock.Oneway",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{},
OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{
{
MethodName: "Echo",
Handler: protobuf.NewOnewayHandler(
protobuf.OnewayHandlerParams{
Handle: handler.Echo,
NewRequest: newOnewayServiceEchoYARPCRequest,
},
),
},
},
StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{},
},
)
}
|
[
"func",
"BuildOnewayYARPCProcedures",
"(",
"server",
"OnewayYARPCServer",
")",
"[",
"]",
"transport",
".",
"Procedure",
"{",
"handler",
":=",
"&",
"_OnewayYARPCHandler",
"{",
"server",
"}",
"\n",
"return",
"protobuf",
".",
"BuildProcedures",
"(",
"protobuf",
".",
"BuildProceduresParams",
"{",
"ServiceName",
":",
"\"",
"\"",
",",
"UnaryHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresUnaryHandlerParams",
"{",
"}",
",",
"OnewayHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresOnewayHandlerParams",
"{",
"{",
"MethodName",
":",
"\"",
"\"",
",",
"Handler",
":",
"protobuf",
".",
"NewOnewayHandler",
"(",
"protobuf",
".",
"OnewayHandlerParams",
"{",
"Handle",
":",
"handler",
".",
"Echo",
",",
"NewRequest",
":",
"newOnewayServiceEchoYARPCRequest",
",",
"}",
",",
")",
",",
"}",
",",
"}",
",",
"StreamHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresStreamHandlerParams",
"{",
"}",
",",
"}",
",",
")",
"\n",
"}"
] |
// BuildOnewayYARPCProcedures prepares an implementation of the Oneway service for YARPC registration.
|
[
"BuildOnewayYARPCProcedures",
"prepares",
"an",
"implementation",
"of",
"the",
"Oneway",
"service",
"for",
"YARPC",
"registration",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/crossdockpb/crossdock.pb.yarpc.go#L238-L258
|
10,979 |
yarpc/yarpc-go
|
internal/crossdock/server/yarpc/error.go
|
BadResponse
|
func BadResponse(ctx context.Context, body map[string]interface{}) (map[string]interface{}, error) {
// func is not serializable
result := map[string]interface{}{"foo": func() {}}
return result, nil
}
|
go
|
func BadResponse(ctx context.Context, body map[string]interface{}) (map[string]interface{}, error) {
// func is not serializable
result := map[string]interface{}{"foo": func() {}}
return result, nil
}
|
[
"func",
"BadResponse",
"(",
"ctx",
"context",
".",
"Context",
",",
"body",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"// func is not serializable",
"result",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"func",
"(",
")",
"{",
"}",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] |
// BadResponse returns an object that's not a valid JSON response.
|
[
"BadResponse",
"returns",
"an",
"object",
"that",
"s",
"not",
"a",
"valid",
"JSON",
"response",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/server/yarpc/error.go#L34-L38
|
10,980 |
yarpc/yarpc-go
|
internal/crossdock/server/oneway/echo.go
|
callHome
|
func (o *onewayHandler) callHome(ctx context.Context, callBackAddr string, body []byte, encoding transport.Encoding) {
// reduce the chance of a race condition
time.Sleep(time.Millisecond * 100)
if callBackAddr == "" {
panic("could not find callBackAddr in headers")
}
out := o.httpTransport.NewSingleOutbound("http://" + callBackAddr)
if err := out.Start(); err != nil {
panic(fmt.Sprintf("could not start outbound: %s", err))
}
defer out.Stop()
ctx, cancel := context.WithTimeout(ctx, time.Second)
defer cancel()
_, err := out.CallOneway(ctx, &transport.Request{
Caller: "oneway-server",
Service: "oneway-client",
Procedure: "call-back",
Encoding: raw.Encoding,
Body: bytes.NewReader(body),
})
if err != nil {
panic(fmt.Sprintf("could not make call back to client: %s", err))
}
}
|
go
|
func (o *onewayHandler) callHome(ctx context.Context, callBackAddr string, body []byte, encoding transport.Encoding) {
// reduce the chance of a race condition
time.Sleep(time.Millisecond * 100)
if callBackAddr == "" {
panic("could not find callBackAddr in headers")
}
out := o.httpTransport.NewSingleOutbound("http://" + callBackAddr)
if err := out.Start(); err != nil {
panic(fmt.Sprintf("could not start outbound: %s", err))
}
defer out.Stop()
ctx, cancel := context.WithTimeout(ctx, time.Second)
defer cancel()
_, err := out.CallOneway(ctx, &transport.Request{
Caller: "oneway-server",
Service: "oneway-client",
Procedure: "call-back",
Encoding: raw.Encoding,
Body: bytes.NewReader(body),
})
if err != nil {
panic(fmt.Sprintf("could not make call back to client: %s", err))
}
}
|
[
"func",
"(",
"o",
"*",
"onewayHandler",
")",
"callHome",
"(",
"ctx",
"context",
".",
"Context",
",",
"callBackAddr",
"string",
",",
"body",
"[",
"]",
"byte",
",",
"encoding",
"transport",
".",
"Encoding",
")",
"{",
"// reduce the chance of a race condition",
"time",
".",
"Sleep",
"(",
"time",
".",
"Millisecond",
"*",
"100",
")",
"\n\n",
"if",
"callBackAddr",
"==",
"\"",
"\"",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"out",
":=",
"o",
".",
"httpTransport",
".",
"NewSingleOutbound",
"(",
"\"",
"\"",
"+",
"callBackAddr",
")",
"\n",
"if",
"err",
":=",
"out",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"defer",
"out",
".",
"Stop",
"(",
")",
"\n\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"ctx",
",",
"time",
".",
"Second",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"out",
".",
"CallOneway",
"(",
"ctx",
",",
"&",
"transport",
".",
"Request",
"{",
"Caller",
":",
"\"",
"\"",
",",
"Service",
":",
"\"",
"\"",
",",
"Procedure",
":",
"\"",
"\"",
",",
"Encoding",
":",
"raw",
".",
"Encoding",
",",
"Body",
":",
"bytes",
".",
"NewReader",
"(",
"body",
")",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// callHome extracts the call back address from headers, and makes a raw HTTP
// request using the same context and body
|
[
"callHome",
"extracts",
"the",
"call",
"back",
"address",
"from",
"headers",
"and",
"makes",
"a",
"raw",
"HTTP",
"request",
"using",
"the",
"same",
"context",
"and",
"body"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/server/oneway/echo.go#L63-L90
|
10,981 |
yarpc/yarpc-go
|
api/middleware/router.go
|
ApplyRouteTable
|
func ApplyRouteTable(r transport.RouteTable, m Router) transport.RouteTable {
if m == nil {
return r
}
return routeTableWithMiddleware{r: r, m: m}
}
|
go
|
func ApplyRouteTable(r transport.RouteTable, m Router) transport.RouteTable {
if m == nil {
return r
}
return routeTableWithMiddleware{r: r, m: m}
}
|
[
"func",
"ApplyRouteTable",
"(",
"r",
"transport",
".",
"RouteTable",
",",
"m",
"Router",
")",
"transport",
".",
"RouteTable",
"{",
"if",
"m",
"==",
"nil",
"{",
"return",
"r",
"\n",
"}",
"\n",
"return",
"routeTableWithMiddleware",
"{",
"r",
":",
"r",
",",
"m",
":",
"m",
"}",
"\n",
"}"
] |
// ApplyRouteTable applies the given Router middleware to the given Router.
|
[
"ApplyRouteTable",
"applies",
"the",
"given",
"Router",
"middleware",
"to",
"the",
"given",
"Router",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/middleware/router.go#L42-L47
|
10,982 |
yarpc/yarpc-go
|
transport/http/config.go
|
TransportSpec
|
func TransportSpec(opts ...Option) yarpcconfig.TransportSpec {
var ts transportSpec
for _, o := range opts {
switch opt := o.(type) {
case TransportOption:
ts.TransportOptions = append(ts.TransportOptions, opt)
case InboundOption:
ts.InboundOptions = append(ts.InboundOptions, opt)
case OutboundOption:
ts.OutboundOptions = append(ts.OutboundOptions, opt)
default:
panic(fmt.Sprintf("unknown option of type %T: %v", o, o))
}
}
return ts.Spec()
}
|
go
|
func TransportSpec(opts ...Option) yarpcconfig.TransportSpec {
var ts transportSpec
for _, o := range opts {
switch opt := o.(type) {
case TransportOption:
ts.TransportOptions = append(ts.TransportOptions, opt)
case InboundOption:
ts.InboundOptions = append(ts.InboundOptions, opt)
case OutboundOption:
ts.OutboundOptions = append(ts.OutboundOptions, opt)
default:
panic(fmt.Sprintf("unknown option of type %T: %v", o, o))
}
}
return ts.Spec()
}
|
[
"func",
"TransportSpec",
"(",
"opts",
"...",
"Option",
")",
"yarpcconfig",
".",
"TransportSpec",
"{",
"var",
"ts",
"transportSpec",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"opts",
"{",
"switch",
"opt",
":=",
"o",
".",
"(",
"type",
")",
"{",
"case",
"TransportOption",
":",
"ts",
".",
"TransportOptions",
"=",
"append",
"(",
"ts",
".",
"TransportOptions",
",",
"opt",
")",
"\n",
"case",
"InboundOption",
":",
"ts",
".",
"InboundOptions",
"=",
"append",
"(",
"ts",
".",
"InboundOptions",
",",
"opt",
")",
"\n",
"case",
"OutboundOption",
":",
"ts",
".",
"OutboundOptions",
"=",
"append",
"(",
"ts",
".",
"OutboundOptions",
",",
"opt",
")",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"o",
",",
"o",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ts",
".",
"Spec",
"(",
")",
"\n",
"}"
] |
// TransportSpec returns a TransportSpec for the HTTP transport.
//
// See TransportConfig, InboundConfig, and OutboundConfig for details on the
// different configuration parameters supported by this Transport.
//
// Any Transport, Inbound or Outbound option may be passed to this function.
// These options will be applied BEFORE configuration parameters are
// interpreted. This allows configuration parameters to override Option
// provided to TransportSpec.
|
[
"TransportSpec",
"returns",
"a",
"TransportSpec",
"for",
"the",
"HTTP",
"transport",
".",
"See",
"TransportConfig",
"InboundConfig",
"and",
"OutboundConfig",
"for",
"details",
"on",
"the",
"different",
"configuration",
"parameters",
"supported",
"by",
"this",
"Transport",
".",
"Any",
"Transport",
"Inbound",
"or",
"Outbound",
"option",
"may",
"be",
"passed",
"to",
"this",
"function",
".",
"These",
"options",
"will",
"be",
"applied",
"BEFORE",
"configuration",
"parameters",
"are",
"interpreted",
".",
"This",
"allows",
"configuration",
"parameters",
"to",
"override",
"Option",
"provided",
"to",
"TransportSpec",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/http/config.go#L41-L56
|
10,983 |
yarpc/yarpc-go
|
internal/bufferpool/bufferpool.go
|
NewPool
|
func NewPool(opts ...Option) *Pool {
pool := &Pool{}
for _, opt := range opts {
opt(pool)
}
return pool
}
|
go
|
func NewPool(opts ...Option) *Pool {
pool := &Pool{}
for _, opt := range opts {
opt(pool)
}
return pool
}
|
[
"func",
"NewPool",
"(",
"opts",
"...",
"Option",
")",
"*",
"Pool",
"{",
"pool",
":=",
"&",
"Pool",
"{",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"pool",
")",
"\n",
"}",
"\n",
"return",
"pool",
"\n",
"}"
] |
// NewPool returns a pool that we can allocate buffers from.
|
[
"NewPool",
"returns",
"a",
"pool",
"that",
"we",
"can",
"allocate",
"buffers",
"from",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/bufferpool/bufferpool.go#L51-L57
|
10,984 |
yarpc/yarpc-go
|
internal/bufferpool/bufferpool.go
|
Get
|
func (p *Pool) Get() *Buffer {
buf, ok := p.pool.Get().(*Buffer)
if !ok {
buf = newBuffer(p)
} else {
buf.reuse()
}
return buf
}
|
go
|
func (p *Pool) Get() *Buffer {
buf, ok := p.pool.Get().(*Buffer)
if !ok {
buf = newBuffer(p)
} else {
buf.reuse()
}
return buf
}
|
[
"func",
"(",
"p",
"*",
"Pool",
")",
"Get",
"(",
")",
"*",
"Buffer",
"{",
"buf",
",",
"ok",
":=",
"p",
".",
"pool",
".",
"Get",
"(",
")",
".",
"(",
"*",
"Buffer",
")",
"\n",
"if",
"!",
"ok",
"{",
"buf",
"=",
"newBuffer",
"(",
"p",
")",
"\n",
"}",
"else",
"{",
"buf",
".",
"reuse",
"(",
")",
"\n",
"}",
"\n",
"return",
"buf",
"\n",
"}"
] |
// Get returns a buffer from the pool.
|
[
"Get",
"returns",
"a",
"buffer",
"from",
"the",
"pool",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/bufferpool/bufferpool.go#L68-L76
|
10,985 |
yarpc/yarpc-go
|
api/encoding/call_option.go
|
ResponseHeaders
|
func ResponseHeaders(h *map[string]string) CallOption {
return CallOption{func(o *OutboundCall) { o.responseHeaders = h }}
}
|
go
|
func ResponseHeaders(h *map[string]string) CallOption {
return CallOption{func(o *OutboundCall) { o.responseHeaders = h }}
}
|
[
"func",
"ResponseHeaders",
"(",
"h",
"*",
"map",
"[",
"string",
"]",
"string",
")",
"CallOption",
"{",
"return",
"CallOption",
"{",
"func",
"(",
"o",
"*",
"OutboundCall",
")",
"{",
"o",
".",
"responseHeaders",
"=",
"h",
"}",
"}",
"\n",
"}"
] |
// ResponseHeaders specifies that headers received in response to this request
// should replace the given map.
|
[
"ResponseHeaders",
"specifies",
"that",
"headers",
"received",
"in",
"response",
"to",
"this",
"request",
"should",
"replace",
"the",
"given",
"map",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/call_option.go#L33-L35
|
10,986 |
yarpc/yarpc-go
|
api/encoding/call_option.go
|
WithHeader
|
func WithHeader(k, v string) CallOption {
return CallOption{func(o *OutboundCall) {
o.headers = append(o.headers, keyValuePair{k: k, v: v})
}}
}
|
go
|
func WithHeader(k, v string) CallOption {
return CallOption{func(o *OutboundCall) {
o.headers = append(o.headers, keyValuePair{k: k, v: v})
}}
}
|
[
"func",
"WithHeader",
"(",
"k",
",",
"v",
"string",
")",
"CallOption",
"{",
"return",
"CallOption",
"{",
"func",
"(",
"o",
"*",
"OutboundCall",
")",
"{",
"o",
".",
"headers",
"=",
"append",
"(",
"o",
".",
"headers",
",",
"keyValuePair",
"{",
"k",
":",
"k",
",",
"v",
":",
"v",
"}",
")",
"\n",
"}",
"}",
"\n",
"}"
] |
// WithHeader adds a new header to the request.
|
[
"WithHeader",
"adds",
"a",
"new",
"header",
"to",
"the",
"request",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/call_option.go#L38-L42
|
10,987 |
yarpc/yarpc-go
|
api/encoding/call_option.go
|
WithShardKey
|
func WithShardKey(sk string) CallOption {
return CallOption{func(o *OutboundCall) { o.shardKey = &sk }}
}
|
go
|
func WithShardKey(sk string) CallOption {
return CallOption{func(o *OutboundCall) { o.shardKey = &sk }}
}
|
[
"func",
"WithShardKey",
"(",
"sk",
"string",
")",
"CallOption",
"{",
"return",
"CallOption",
"{",
"func",
"(",
"o",
"*",
"OutboundCall",
")",
"{",
"o",
".",
"shardKey",
"=",
"&",
"sk",
"}",
"}",
"\n",
"}"
] |
// WithShardKey sets the shard key for the request.
|
[
"WithShardKey",
"sets",
"the",
"shard",
"key",
"for",
"the",
"request",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/call_option.go#L45-L47
|
10,988 |
yarpc/yarpc-go
|
api/encoding/call_option.go
|
WithRoutingKey
|
func WithRoutingKey(rk string) CallOption {
return CallOption{func(o *OutboundCall) { o.routingKey = &rk }}
}
|
go
|
func WithRoutingKey(rk string) CallOption {
return CallOption{func(o *OutboundCall) { o.routingKey = &rk }}
}
|
[
"func",
"WithRoutingKey",
"(",
"rk",
"string",
")",
"CallOption",
"{",
"return",
"CallOption",
"{",
"func",
"(",
"o",
"*",
"OutboundCall",
")",
"{",
"o",
".",
"routingKey",
"=",
"&",
"rk",
"}",
"}",
"\n",
"}"
] |
// WithRoutingKey sets the routing key for the request.
|
[
"WithRoutingKey",
"sets",
"the",
"routing",
"key",
"for",
"the",
"request",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/call_option.go#L50-L52
|
10,989 |
yarpc/yarpc-go
|
api/encoding/call_option.go
|
WithRoutingDelegate
|
func WithRoutingDelegate(rd string) CallOption {
return CallOption{func(o *OutboundCall) { o.routingDelegate = &rd }}
}
|
go
|
func WithRoutingDelegate(rd string) CallOption {
return CallOption{func(o *OutboundCall) { o.routingDelegate = &rd }}
}
|
[
"func",
"WithRoutingDelegate",
"(",
"rd",
"string",
")",
"CallOption",
"{",
"return",
"CallOption",
"{",
"func",
"(",
"o",
"*",
"OutboundCall",
")",
"{",
"o",
".",
"routingDelegate",
"=",
"&",
"rd",
"}",
"}",
"\n",
"}"
] |
// WithRoutingDelegate sets the routing delegate for the request.
|
[
"WithRoutingDelegate",
"sets",
"the",
"routing",
"delegate",
"for",
"the",
"request",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/api/encoding/call_option.go#L55-L57
|
10,990 |
yarpc/yarpc-go
|
internal/crossdock/client/echo/json.go
|
JSONForTransport
|
func JSONForTransport(t crossdock.T, transport string) {
t = createEchoT("json", transport, t)
fatals := crossdock.Fatals(t)
dispatcher := disp.CreateDispatcherForTransport(t, transport)
fatals.NoError(dispatcher.Start(), "could not start Dispatcher")
defer dispatcher.Stop()
client := json.New(dispatcher.ClientConfig("yarpc-test"))
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
var response jsonEcho
token := random.String(5)
err := client.Call(ctx, "echo", &jsonEcho{Token: token}, &response)
crossdock.Fatals(t).NoError(err, "call to echo failed: %v", err)
crossdock.Assert(t).Equal(token, response.Token, "server said: %v", response.Token)
}
|
go
|
func JSONForTransport(t crossdock.T, transport string) {
t = createEchoT("json", transport, t)
fatals := crossdock.Fatals(t)
dispatcher := disp.CreateDispatcherForTransport(t, transport)
fatals.NoError(dispatcher.Start(), "could not start Dispatcher")
defer dispatcher.Stop()
client := json.New(dispatcher.ClientConfig("yarpc-test"))
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
var response jsonEcho
token := random.String(5)
err := client.Call(ctx, "echo", &jsonEcho{Token: token}, &response)
crossdock.Fatals(t).NoError(err, "call to echo failed: %v", err)
crossdock.Assert(t).Equal(token, response.Token, "server said: %v", response.Token)
}
|
[
"func",
"JSONForTransport",
"(",
"t",
"crossdock",
".",
"T",
",",
"transport",
"string",
")",
"{",
"t",
"=",
"createEchoT",
"(",
"\"",
"\"",
",",
"transport",
",",
"t",
")",
"\n",
"fatals",
":=",
"crossdock",
".",
"Fatals",
"(",
"t",
")",
"\n\n",
"dispatcher",
":=",
"disp",
".",
"CreateDispatcherForTransport",
"(",
"t",
",",
"transport",
")",
"\n",
"fatals",
".",
"NoError",
"(",
"dispatcher",
".",
"Start",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"defer",
"dispatcher",
".",
"Stop",
"(",
")",
"\n\n",
"client",
":=",
"json",
".",
"New",
"(",
"dispatcher",
".",
"ClientConfig",
"(",
"\"",
"\"",
")",
")",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"context",
".",
"Background",
"(",
")",
",",
"time",
".",
"Second",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"var",
"response",
"jsonEcho",
"\n",
"token",
":=",
"random",
".",
"String",
"(",
"5",
")",
"\n",
"err",
":=",
"client",
".",
"Call",
"(",
"ctx",
",",
"\"",
"\"",
",",
"&",
"jsonEcho",
"{",
"Token",
":",
"token",
"}",
",",
"&",
"response",
")",
"\n",
"crossdock",
".",
"Fatals",
"(",
"t",
")",
".",
"NoError",
"(",
"err",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"crossdock",
".",
"Assert",
"(",
"t",
")",
".",
"Equal",
"(",
"token",
",",
"response",
".",
"Token",
",",
"\"",
"\"",
",",
"response",
".",
"Token",
")",
"\n",
"}"
] |
// JSONForTransport implements the 'json' behavior for the given transport or behavior transport.
|
[
"JSONForTransport",
"implements",
"the",
"json",
"behavior",
"for",
"the",
"given",
"transport",
"or",
"behavior",
"transport",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/client/echo/json.go#L44-L61
|
10,991 |
yarpc/yarpc-go
|
internal/examples/thrift-oneway/sink/hello_sink.go
|
String
|
func (v *Hello_Sink_Args) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Snk != nil {
fields[i] = fmt.Sprintf("Snk: %v", v.Snk)
i++
}
return fmt.Sprintf("Hello_Sink_Args{%v}", strings.Join(fields[:i], ", "))
}
|
go
|
func (v *Hello_Sink_Args) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Snk != nil {
fields[i] = fmt.Sprintf("Snk: %v", v.Snk)
i++
}
return fmt.Sprintf("Hello_Sink_Args{%v}", strings.Join(fields[:i], ", "))
}
|
[
"func",
"(",
"v",
"*",
"Hello_Sink_Args",
")",
"String",
"(",
")",
"string",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"var",
"fields",
"[",
"1",
"]",
"string",
"\n",
"i",
":=",
"0",
"\n",
"if",
"v",
".",
"Snk",
"!=",
"nil",
"{",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"Snk",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"fields",
"[",
":",
"i",
"]",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// String returns a readable string representation of a Hello_Sink_Args
// struct.
|
[
"String",
"returns",
"a",
"readable",
"string",
"representation",
"of",
"a",
"Hello_Sink_Args",
"struct",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-oneway/sink/hello_sink.go#L120-L133
|
10,992 |
yarpc/yarpc-go
|
internal/examples/thrift-oneway/sink/hello_sink.go
|
Equals
|
func (v *Hello_Sink_Args) Equals(rhs *Hello_Sink_Args) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Snk == nil && rhs.Snk == nil) || (v.Snk != nil && rhs.Snk != nil && v.Snk.Equals(rhs.Snk))) {
return false
}
return true
}
|
go
|
func (v *Hello_Sink_Args) Equals(rhs *Hello_Sink_Args) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Snk == nil && rhs.Snk == nil) || (v.Snk != nil && rhs.Snk != nil && v.Snk.Equals(rhs.Snk))) {
return false
}
return true
}
|
[
"func",
"(",
"v",
"*",
"Hello_Sink_Args",
")",
"Equals",
"(",
"rhs",
"*",
"Hello_Sink_Args",
")",
"bool",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"rhs",
"==",
"nil",
"\n",
"}",
"else",
"if",
"rhs",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"(",
"v",
".",
"Snk",
"==",
"nil",
"&&",
"rhs",
".",
"Snk",
"==",
"nil",
")",
"||",
"(",
"v",
".",
"Snk",
"!=",
"nil",
"&&",
"rhs",
".",
"Snk",
"!=",
"nil",
"&&",
"v",
".",
"Snk",
".",
"Equals",
"(",
"rhs",
".",
"Snk",
")",
")",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Equals returns true if all the fields of this Hello_Sink_Args match the
// provided Hello_Sink_Args.
//
// This function performs a deep comparison.
|
[
"Equals",
"returns",
"true",
"if",
"all",
"the",
"fields",
"of",
"this",
"Hello_Sink_Args",
"match",
"the",
"provided",
"Hello_Sink_Args",
".",
"This",
"function",
"performs",
"a",
"deep",
"comparison",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-oneway/sink/hello_sink.go#L139-L150
|
10,993 |
yarpc/yarpc-go
|
internal/examples/thrift-oneway/sink/hello_sink.go
|
MarshalLogObject
|
func (v *Hello_Sink_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Snk != nil {
err = multierr.Append(err, enc.AddObject("snk", v.Snk))
}
return err
}
|
go
|
func (v *Hello_Sink_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Snk != nil {
err = multierr.Append(err, enc.AddObject("snk", v.Snk))
}
return err
}
|
[
"func",
"(",
"v",
"*",
"Hello_Sink_Args",
")",
"MarshalLogObject",
"(",
"enc",
"zapcore",
".",
"ObjectEncoder",
")",
"(",
"err",
"error",
")",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"v",
".",
"Snk",
"!=",
"nil",
"{",
"err",
"=",
"multierr",
".",
"Append",
"(",
"err",
",",
"enc",
".",
"AddObject",
"(",
"\"",
"\"",
",",
"v",
".",
"Snk",
")",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of Hello_Sink_Args.
|
[
"MarshalLogObject",
"implements",
"zapcore",
".",
"ObjectMarshaler",
"enabling",
"fast",
"logging",
"of",
"Hello_Sink_Args",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-oneway/sink/hello_sink.go#L154-L162
|
10,994 |
yarpc/yarpc-go
|
internal/examples/thrift-oneway/sink/hello_sink.go
|
GetSnk
|
func (v *Hello_Sink_Args) GetSnk() (o *SinkRequest) {
if v != nil && v.Snk != nil {
return v.Snk
}
return
}
|
go
|
func (v *Hello_Sink_Args) GetSnk() (o *SinkRequest) {
if v != nil && v.Snk != nil {
return v.Snk
}
return
}
|
[
"func",
"(",
"v",
"*",
"Hello_Sink_Args",
")",
"GetSnk",
"(",
")",
"(",
"o",
"*",
"SinkRequest",
")",
"{",
"if",
"v",
"!=",
"nil",
"&&",
"v",
".",
"Snk",
"!=",
"nil",
"{",
"return",
"v",
".",
"Snk",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// GetSnk returns the value of Snk if it is set or its
// zero value if it is unset.
|
[
"GetSnk",
"returns",
"the",
"value",
"of",
"Snk",
"if",
"it",
"is",
"set",
"or",
"its",
"zero",
"value",
"if",
"it",
"is",
"unset",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-oneway/sink/hello_sink.go#L166-L172
|
10,995 |
yarpc/yarpc-go
|
internal/config/attributemap.go
|
PopString
|
func (m AttributeMap) PopString(name string) (string, error) {
var s string
_, err := m.Pop(name, &s)
return s, err
}
|
go
|
func (m AttributeMap) PopString(name string) (string, error) {
var s string
_, err := m.Pop(name, &s)
return s, err
}
|
[
"func",
"(",
"m",
"AttributeMap",
")",
"PopString",
"(",
"name",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"s",
"string",
"\n",
"_",
",",
"err",
":=",
"m",
".",
"Pop",
"(",
"name",
",",
"&",
"s",
")",
"\n",
"return",
"s",
",",
"err",
"\n",
"}"
] |
// PopString will pop a value from the attribute map and return the string
// it points to, or an error if it couldn't pop the value and decode.
|
[
"PopString",
"will",
"pop",
"a",
"value",
"from",
"the",
"attribute",
"map",
"and",
"return",
"the",
"string",
"it",
"points",
"to",
"or",
"an",
"error",
"if",
"it",
"couldn",
"t",
"pop",
"the",
"value",
"and",
"decode",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/config/attributemap.go#L35-L39
|
10,996 |
yarpc/yarpc-go
|
internal/config/attributemap.go
|
PopBool
|
func (m AttributeMap) PopBool(name string) (bool, error) {
var b bool
_, err := m.Pop(name, &b)
return b, err
}
|
go
|
func (m AttributeMap) PopBool(name string) (bool, error) {
var b bool
_, err := m.Pop(name, &b)
return b, err
}
|
[
"func",
"(",
"m",
"AttributeMap",
")",
"PopBool",
"(",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"var",
"b",
"bool",
"\n",
"_",
",",
"err",
":=",
"m",
".",
"Pop",
"(",
"name",
",",
"&",
"b",
")",
"\n",
"return",
"b",
",",
"err",
"\n",
"}"
] |
// PopBool will pop a value from the attribute map and return the bool
// it points to, or an error if it couldn't pop the value and decode.
|
[
"PopBool",
"will",
"pop",
"a",
"value",
"from",
"the",
"attribute",
"map",
"and",
"return",
"the",
"bool",
"it",
"points",
"to",
"or",
"an",
"error",
"if",
"it",
"couldn",
"t",
"pop",
"the",
"value",
"and",
"decode",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/config/attributemap.go#L43-L47
|
10,997 |
yarpc/yarpc-go
|
internal/config/attributemap.go
|
Pop
|
func (m AttributeMap) Pop(name string, dst interface{}, opts ...mapdecode.Option) (bool, error) {
ok, err := m.Get(name, dst, opts...)
if ok {
delete(m, name)
}
return ok, err
}
|
go
|
func (m AttributeMap) Pop(name string, dst interface{}, opts ...mapdecode.Option) (bool, error) {
ok, err := m.Get(name, dst, opts...)
if ok {
delete(m, name)
}
return ok, err
}
|
[
"func",
"(",
"m",
"AttributeMap",
")",
"Pop",
"(",
"name",
"string",
",",
"dst",
"interface",
"{",
"}",
",",
"opts",
"...",
"mapdecode",
".",
"Option",
")",
"(",
"bool",
",",
"error",
")",
"{",
"ok",
",",
"err",
":=",
"m",
".",
"Get",
"(",
"name",
",",
"dst",
",",
"opts",
"...",
")",
"\n",
"if",
"ok",
"{",
"delete",
"(",
"m",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"ok",
",",
"err",
"\n",
"}"
] |
// Pop removes the named key from the AttributeMap and decodes the value into
// the dst interface.
|
[
"Pop",
"removes",
"the",
"named",
"key",
"from",
"the",
"AttributeMap",
"and",
"decodes",
"the",
"value",
"into",
"the",
"dst",
"interface",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/config/attributemap.go#L51-L57
|
10,998 |
yarpc/yarpc-go
|
internal/config/attributemap.go
|
Get
|
func (m AttributeMap) Get(name string, dst interface{}, opts ...mapdecode.Option) (bool, error) {
v, ok := m[name]
if !ok {
return ok, nil
}
err := DecodeInto(dst, v, opts...)
if err != nil {
err = fmt.Errorf("failed to read attribute %q: %v. got error: %s", name, v, err)
}
return true, err
}
|
go
|
func (m AttributeMap) Get(name string, dst interface{}, opts ...mapdecode.Option) (bool, error) {
v, ok := m[name]
if !ok {
return ok, nil
}
err := DecodeInto(dst, v, opts...)
if err != nil {
err = fmt.Errorf("failed to read attribute %q: %v. got error: %s", name, v, err)
}
return true, err
}
|
[
"func",
"(",
"m",
"AttributeMap",
")",
"Get",
"(",
"name",
"string",
",",
"dst",
"interface",
"{",
"}",
",",
"opts",
"...",
"mapdecode",
".",
"Option",
")",
"(",
"bool",
",",
"error",
")",
"{",
"v",
",",
"ok",
":=",
"m",
"[",
"name",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"ok",
",",
"nil",
"\n",
"}",
"\n\n",
"err",
":=",
"DecodeInto",
"(",
"dst",
",",
"v",
",",
"opts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
",",
"v",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"true",
",",
"err",
"\n",
"}"
] |
// Get grabs a value from the attribute map and decodes it into the dst
// interface.
|
[
"Get",
"grabs",
"a",
"value",
"from",
"the",
"attribute",
"map",
"and",
"decodes",
"it",
"into",
"the",
"dst",
"interface",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/config/attributemap.go#L61-L72
|
10,999 |
yarpc/yarpc-go
|
internal/config/attributemap.go
|
Keys
|
func (m AttributeMap) Keys() []string {
keys := make([]string, 0, len(m))
for key := range m {
keys = append(keys, key)
}
return keys
}
|
go
|
func (m AttributeMap) Keys() []string {
keys := make([]string, 0, len(m))
for key := range m {
keys = append(keys, key)
}
return keys
}
|
[
"func",
"(",
"m",
"AttributeMap",
")",
"Keys",
"(",
")",
"[",
"]",
"string",
"{",
"keys",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"m",
")",
")",
"\n",
"for",
"key",
":=",
"range",
"m",
"{",
"keys",
"=",
"append",
"(",
"keys",
",",
"key",
")",
"\n",
"}",
"\n",
"return",
"keys",
"\n",
"}"
] |
// Keys returns all the keys of the attribute map.
|
[
"Keys",
"returns",
"all",
"the",
"keys",
"of",
"the",
"attribute",
"map",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/config/attributemap.go#L75-L81
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.