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,500 |
yarpc/yarpc-go
|
peer/peerlist/peer.go
|
Subscriber
|
func (t *peerThunk) Subscriber() peer.Subscriber {
t.lock.RLock()
s := t.subscriber
t.lock.RUnlock()
return s
}
|
go
|
func (t *peerThunk) Subscriber() peer.Subscriber {
t.lock.RLock()
s := t.subscriber
t.lock.RUnlock()
return s
}
|
[
"func",
"(",
"t",
"*",
"peerThunk",
")",
"Subscriber",
"(",
")",
"peer",
".",
"Subscriber",
"{",
"t",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"s",
":=",
"t",
".",
"subscriber",
"\n",
"t",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"s",
"\n",
"}"
] |
// Subscriber returns the subscriber.
|
[
"Subscriber",
"returns",
"the",
"subscriber",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/peerlist/peer.go#L83-L88
|
10,501 |
yarpc/yarpc-go
|
internal/examples/thrift-hello/hello/echo/hello_echo.go
|
String
|
func (v *Hello_Echo_Args) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Echo != nil {
fields[i] = fmt.Sprintf("Echo: %v", v.Echo)
i++
}
return fmt.Sprintf("Hello_Echo_Args{%v}", strings.Join(fields[:i], ", "))
}
|
go
|
func (v *Hello_Echo_Args) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Echo != nil {
fields[i] = fmt.Sprintf("Echo: %v", v.Echo)
i++
}
return fmt.Sprintf("Hello_Echo_Args{%v}", strings.Join(fields[:i], ", "))
}
|
[
"func",
"(",
"v",
"*",
"Hello_Echo_Args",
")",
"String",
"(",
")",
"string",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"var",
"fields",
"[",
"1",
"]",
"string",
"\n",
"i",
":=",
"0",
"\n",
"if",
"v",
".",
"Echo",
"!=",
"nil",
"{",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"Echo",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"fields",
"[",
":",
"i",
"]",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// String returns a readable string representation of a Hello_Echo_Args
// struct.
|
[
"String",
"returns",
"a",
"readable",
"string",
"representation",
"of",
"a",
"Hello_Echo_Args",
"struct",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-hello/hello/echo/hello_echo.go#L121-L134
|
10,502 |
yarpc/yarpc-go
|
internal/examples/thrift-hello/hello/echo/hello_echo.go
|
Equals
|
func (v *Hello_Echo_Args) Equals(rhs *Hello_Echo_Args) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Echo == nil && rhs.Echo == nil) || (v.Echo != nil && rhs.Echo != nil && v.Echo.Equals(rhs.Echo))) {
return false
}
return true
}
|
go
|
func (v *Hello_Echo_Args) Equals(rhs *Hello_Echo_Args) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Echo == nil && rhs.Echo == nil) || (v.Echo != nil && rhs.Echo != nil && v.Echo.Equals(rhs.Echo))) {
return false
}
return true
}
|
[
"func",
"(",
"v",
"*",
"Hello_Echo_Args",
")",
"Equals",
"(",
"rhs",
"*",
"Hello_Echo_Args",
")",
"bool",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"rhs",
"==",
"nil",
"\n",
"}",
"else",
"if",
"rhs",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"(",
"v",
".",
"Echo",
"==",
"nil",
"&&",
"rhs",
".",
"Echo",
"==",
"nil",
")",
"||",
"(",
"v",
".",
"Echo",
"!=",
"nil",
"&&",
"rhs",
".",
"Echo",
"!=",
"nil",
"&&",
"v",
".",
"Echo",
".",
"Equals",
"(",
"rhs",
".",
"Echo",
")",
")",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Equals returns true if all the fields of this Hello_Echo_Args match the
// provided Hello_Echo_Args.
//
// This function performs a deep comparison.
|
[
"Equals",
"returns",
"true",
"if",
"all",
"the",
"fields",
"of",
"this",
"Hello_Echo_Args",
"match",
"the",
"provided",
"Hello_Echo_Args",
".",
"This",
"function",
"performs",
"a",
"deep",
"comparison",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-hello/hello/echo/hello_echo.go#L140-L151
|
10,503 |
yarpc/yarpc-go
|
internal/examples/thrift-hello/hello/echo/hello_echo.go
|
MarshalLogObject
|
func (v *Hello_Echo_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Echo != nil {
err = multierr.Append(err, enc.AddObject("echo", v.Echo))
}
return err
}
|
go
|
func (v *Hello_Echo_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Echo != nil {
err = multierr.Append(err, enc.AddObject("echo", v.Echo))
}
return err
}
|
[
"func",
"(",
"v",
"*",
"Hello_Echo_Args",
")",
"MarshalLogObject",
"(",
"enc",
"zapcore",
".",
"ObjectEncoder",
")",
"(",
"err",
"error",
")",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"v",
".",
"Echo",
"!=",
"nil",
"{",
"err",
"=",
"multierr",
".",
"Append",
"(",
"err",
",",
"enc",
".",
"AddObject",
"(",
"\"",
"\"",
",",
"v",
".",
"Echo",
")",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of Hello_Echo_Args.
|
[
"MarshalLogObject",
"implements",
"zapcore",
".",
"ObjectMarshaler",
"enabling",
"fast",
"logging",
"of",
"Hello_Echo_Args",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-hello/hello/echo/hello_echo.go#L155-L163
|
10,504 |
yarpc/yarpc-go
|
internal/examples/thrift-hello/hello/echo/hello_echo.go
|
GetEcho
|
func (v *Hello_Echo_Args) GetEcho() (o *EchoRequest) {
if v != nil && v.Echo != nil {
return v.Echo
}
return
}
|
go
|
func (v *Hello_Echo_Args) GetEcho() (o *EchoRequest) {
if v != nil && v.Echo != nil {
return v.Echo
}
return
}
|
[
"func",
"(",
"v",
"*",
"Hello_Echo_Args",
")",
"GetEcho",
"(",
")",
"(",
"o",
"*",
"EchoRequest",
")",
"{",
"if",
"v",
"!=",
"nil",
"&&",
"v",
".",
"Echo",
"!=",
"nil",
"{",
"return",
"v",
".",
"Echo",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// GetEcho returns the value of Echo if it is set or its
// zero value if it is unset.
|
[
"GetEcho",
"returns",
"the",
"value",
"of",
"Echo",
"if",
"it",
"is",
"set",
"or",
"its",
"zero",
"value",
"if",
"it",
"is",
"unset",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-hello/hello/echo/hello_echo.go#L167-L173
|
10,505 |
yarpc/yarpc-go
|
yarpcerrors/errors.go
|
Newf
|
func Newf(code Code, format string, args ...interface{}) *Status {
if code == CodeOK {
return nil
}
return &Status{
code: code,
message: sprintf(format, args...),
}
}
|
go
|
func Newf(code Code, format string, args ...interface{}) *Status {
if code == CodeOK {
return nil
}
return &Status{
code: code,
message: sprintf(format, args...),
}
}
|
[
"func",
"Newf",
"(",
"code",
"Code",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Status",
"{",
"if",
"code",
"==",
"CodeOK",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"Status",
"{",
"code",
":",
"code",
",",
"message",
":",
"sprintf",
"(",
"format",
",",
"args",
"...",
")",
",",
"}",
"\n",
"}"
] |
// Newf returns a new Status.
//
// The Code should never be CodeOK, if it is, this will return nil.
|
[
"Newf",
"returns",
"a",
"new",
"Status",
".",
"The",
"Code",
"should",
"never",
"be",
"CodeOK",
"if",
"it",
"is",
"this",
"will",
"return",
"nil",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcerrors/errors.go#L31-L39
|
10,506 |
yarpc/yarpc-go
|
yarpcerrors/errors.go
|
FromError
|
func FromError(err error) *Status {
if err == nil {
return nil
}
if status, ok := err.(*Status); ok {
return status
}
return &Status{
code: CodeUnknown,
message: err.Error(),
}
}
|
go
|
func FromError(err error) *Status {
if err == nil {
return nil
}
if status, ok := err.(*Status); ok {
return status
}
return &Status{
code: CodeUnknown,
message: err.Error(),
}
}
|
[
"func",
"FromError",
"(",
"err",
"error",
")",
"*",
"Status",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"status",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"Status",
")",
";",
"ok",
"{",
"return",
"status",
"\n",
"}",
"\n",
"return",
"&",
"Status",
"{",
"code",
":",
"CodeUnknown",
",",
"message",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
"\n",
"}"
] |
// FromError returns the Status for the provided error. If the provided error
// is not a Status, a new error with code CodeUnknown is returned.
//
// Returns nil if the provided error is nil.
|
[
"FromError",
"returns",
"the",
"Status",
"for",
"the",
"provided",
"error",
".",
"If",
"the",
"provided",
"error",
"is",
"not",
"a",
"Status",
"a",
"new",
"error",
"with",
"code",
"CodeUnknown",
"is",
"returned",
".",
"Returns",
"nil",
"if",
"the",
"provided",
"error",
"is",
"nil",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcerrors/errors.go#L45-L56
|
10,507 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
New
|
func New(opts ...Option) *Configurator {
c := &Configurator{
knownTransports: make(map[string]*compiledTransportSpec),
knownPeerChoosers: make(map[string]*compiledPeerChooserSpec),
knownPeerLists: make(map[string]*compiledPeerListSpec),
knownPeerListUpdaters: make(map[string]*compiledPeerListUpdaterSpec),
resolver: os.LookupEnv,
}
for _, opt := range opts {
opt(c)
}
return c
}
|
go
|
func New(opts ...Option) *Configurator {
c := &Configurator{
knownTransports: make(map[string]*compiledTransportSpec),
knownPeerChoosers: make(map[string]*compiledPeerChooserSpec),
knownPeerLists: make(map[string]*compiledPeerListSpec),
knownPeerListUpdaters: make(map[string]*compiledPeerListUpdaterSpec),
resolver: os.LookupEnv,
}
for _, opt := range opts {
opt(c)
}
return c
}
|
[
"func",
"New",
"(",
"opts",
"...",
"Option",
")",
"*",
"Configurator",
"{",
"c",
":=",
"&",
"Configurator",
"{",
"knownTransports",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"compiledTransportSpec",
")",
",",
"knownPeerChoosers",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"compiledPeerChooserSpec",
")",
",",
"knownPeerLists",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"compiledPeerListSpec",
")",
",",
"knownPeerListUpdaters",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"compiledPeerListUpdaterSpec",
")",
",",
"resolver",
":",
"os",
".",
"LookupEnv",
",",
"}",
"\n\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"c",
")",
"\n",
"}",
"\n\n",
"return",
"c",
"\n",
"}"
] |
// New sets up a new empty Configurator. The returned Configurator does not
// know about any Transports, peer lists, or peer list updaters.
|
[
"New",
"sets",
"up",
"a",
"new",
"empty",
"Configurator",
".",
"The",
"returned",
"Configurator",
"does",
"not",
"know",
"about",
"any",
"Transports",
"peer",
"lists",
"or",
"peer",
"list",
"updaters",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L53-L67
|
10,508 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
RegisterTransport
|
func (c *Configurator) RegisterTransport(t TransportSpec) error {
if t.Name == "" {
return errors.New("name is required")
}
spec, err := compileTransportSpec(&t)
if err != nil {
return fmt.Errorf("invalid TransportSpec for %q: %v", t.Name, err)
}
c.knownTransports[t.Name] = spec
return nil
}
|
go
|
func (c *Configurator) RegisterTransport(t TransportSpec) error {
if t.Name == "" {
return errors.New("name is required")
}
spec, err := compileTransportSpec(&t)
if err != nil {
return fmt.Errorf("invalid TransportSpec for %q: %v", t.Name, err)
}
c.knownTransports[t.Name] = spec
return nil
}
|
[
"func",
"(",
"c",
"*",
"Configurator",
")",
"RegisterTransport",
"(",
"t",
"TransportSpec",
")",
"error",
"{",
"if",
"t",
".",
"Name",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"spec",
",",
"err",
":=",
"compileTransportSpec",
"(",
"&",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"t",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n\n",
"c",
".",
"knownTransports",
"[",
"t",
".",
"Name",
"]",
"=",
"spec",
"\n",
"return",
"nil",
"\n",
"}"
] |
// RegisterTransport registers a TransportSpec with the Configurator, teaching
// it how to load configuration and build inbounds and outbounds for that
// transport.
//
// An error is returned if the TransportSpec is invalid. Use
// MustRegisterTransport if you want to panic in case of registration failure.
//
// If a transport with the same name already exists, it will be replaced.
//
// See TransportSpec for details on how to integrate your own transport with
// the system.
|
[
"RegisterTransport",
"registers",
"a",
"TransportSpec",
"with",
"the",
"Configurator",
"teaching",
"it",
"how",
"to",
"load",
"configuration",
"and",
"build",
"inbounds",
"and",
"outbounds",
"for",
"that",
"transport",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"TransportSpec",
"is",
"invalid",
".",
"Use",
"MustRegisterTransport",
"if",
"you",
"want",
"to",
"panic",
"in",
"case",
"of",
"registration",
"failure",
".",
"If",
"a",
"transport",
"with",
"the",
"same",
"name",
"already",
"exists",
"it",
"will",
"be",
"replaced",
".",
"See",
"TransportSpec",
"for",
"details",
"on",
"how",
"to",
"integrate",
"your",
"own",
"transport",
"with",
"the",
"system",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L80-L92
|
10,509 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
MustRegisterTransport
|
func (c *Configurator) MustRegisterTransport(t TransportSpec) {
if err := c.RegisterTransport(t); err != nil {
panic(err)
}
}
|
go
|
func (c *Configurator) MustRegisterTransport(t TransportSpec) {
if err := c.RegisterTransport(t); err != nil {
panic(err)
}
}
|
[
"func",
"(",
"c",
"*",
"Configurator",
")",
"MustRegisterTransport",
"(",
"t",
"TransportSpec",
")",
"{",
"if",
"err",
":=",
"c",
".",
"RegisterTransport",
"(",
"t",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// MustRegisterTransport registers the given TransportSpec with the
// Configurator. This function panics if the TransportSpec is invalid.
|
[
"MustRegisterTransport",
"registers",
"the",
"given",
"TransportSpec",
"with",
"the",
"Configurator",
".",
"This",
"function",
"panics",
"if",
"the",
"TransportSpec",
"is",
"invalid",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L96-L100
|
10,510 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
RegisterPeerChooser
|
func (c *Configurator) RegisterPeerChooser(s PeerChooserSpec) error {
if s.Name == "" {
return errors.New("name is required")
}
spec, err := compilePeerChooserSpec(&s)
if err != nil {
return fmt.Errorf("invalid PeerChooserSpec for %q: %v", s.Name, err)
}
c.knownPeerChoosers[s.Name] = spec
return nil
}
|
go
|
func (c *Configurator) RegisterPeerChooser(s PeerChooserSpec) error {
if s.Name == "" {
return errors.New("name is required")
}
spec, err := compilePeerChooserSpec(&s)
if err != nil {
return fmt.Errorf("invalid PeerChooserSpec for %q: %v", s.Name, err)
}
c.knownPeerChoosers[s.Name] = spec
return nil
}
|
[
"func",
"(",
"c",
"*",
"Configurator",
")",
"RegisterPeerChooser",
"(",
"s",
"PeerChooserSpec",
")",
"error",
"{",
"if",
"s",
".",
"Name",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"spec",
",",
"err",
":=",
"compilePeerChooserSpec",
"(",
"&",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n\n",
"c",
".",
"knownPeerChoosers",
"[",
"s",
".",
"Name",
"]",
"=",
"spec",
"\n",
"return",
"nil",
"\n",
"}"
] |
// RegisterPeerChooser registers a PeerChooserSpec with the given Configurator,
// teaching it how to build peer choosers of this kind from configuration.
//
// An error is returned if the PeerChooserSpec is invalid. Use
// MustRegisterPeerChooser to panic in the case of registration failure.
//
// If a peer chooser with the same name already exists, it will be replaced.
//
// If a peer list is registered with the same name, it will be ignored.
//
// See PeerChooserSpec for details on how to integrate your own peer chooser
// with the system.
|
[
"RegisterPeerChooser",
"registers",
"a",
"PeerChooserSpec",
"with",
"the",
"given",
"Configurator",
"teaching",
"it",
"how",
"to",
"build",
"peer",
"choosers",
"of",
"this",
"kind",
"from",
"configuration",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"PeerChooserSpec",
"is",
"invalid",
".",
"Use",
"MustRegisterPeerChooser",
"to",
"panic",
"in",
"the",
"case",
"of",
"registration",
"failure",
".",
"If",
"a",
"peer",
"chooser",
"with",
"the",
"same",
"name",
"already",
"exists",
"it",
"will",
"be",
"replaced",
".",
"If",
"a",
"peer",
"list",
"is",
"registered",
"with",
"the",
"same",
"name",
"it",
"will",
"be",
"ignored",
".",
"See",
"PeerChooserSpec",
"for",
"details",
"on",
"how",
"to",
"integrate",
"your",
"own",
"peer",
"chooser",
"with",
"the",
"system",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L114-L126
|
10,511 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
MustRegisterPeerChooser
|
func (c *Configurator) MustRegisterPeerChooser(s PeerChooserSpec) {
if err := c.RegisterPeerChooser(s); err != nil {
panic(err)
}
}
|
go
|
func (c *Configurator) MustRegisterPeerChooser(s PeerChooserSpec) {
if err := c.RegisterPeerChooser(s); err != nil {
panic(err)
}
}
|
[
"func",
"(",
"c",
"*",
"Configurator",
")",
"MustRegisterPeerChooser",
"(",
"s",
"PeerChooserSpec",
")",
"{",
"if",
"err",
":=",
"c",
".",
"RegisterPeerChooser",
"(",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// MustRegisterPeerChooser registers the given PeerChooserSpec with the
// Configurator.
// This function panics if the PeerChooserSpec is invalid.
|
[
"MustRegisterPeerChooser",
"registers",
"the",
"given",
"PeerChooserSpec",
"with",
"the",
"Configurator",
".",
"This",
"function",
"panics",
"if",
"the",
"PeerChooserSpec",
"is",
"invalid",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L131-L135
|
10,512 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
RegisterPeerList
|
func (c *Configurator) RegisterPeerList(s PeerListSpec) error {
if s.Name == "" {
return errors.New("name is required")
}
spec, err := compilePeerListSpec(&s)
if err != nil {
return fmt.Errorf("invalid PeerListSpec for %q: %v", s.Name, err)
}
c.knownPeerLists[s.Name] = spec
return nil
}
|
go
|
func (c *Configurator) RegisterPeerList(s PeerListSpec) error {
if s.Name == "" {
return errors.New("name is required")
}
spec, err := compilePeerListSpec(&s)
if err != nil {
return fmt.Errorf("invalid PeerListSpec for %q: %v", s.Name, err)
}
c.knownPeerLists[s.Name] = spec
return nil
}
|
[
"func",
"(",
"c",
"*",
"Configurator",
")",
"RegisterPeerList",
"(",
"s",
"PeerListSpec",
")",
"error",
"{",
"if",
"s",
".",
"Name",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"spec",
",",
"err",
":=",
"compilePeerListSpec",
"(",
"&",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n\n",
"c",
".",
"knownPeerLists",
"[",
"s",
".",
"Name",
"]",
"=",
"spec",
"\n",
"return",
"nil",
"\n",
"}"
] |
// RegisterPeerList registers a PeerListSpec with the given Configurator,
// teaching it how to build peer lists of this kind from configuration.
//
// An error is returned if the PeerListSpec is invalid. Use
// MustRegisterPeerList to panic in the case of registration failure.
//
// If a peer list with the same name already exists, it will be replaced.
//
// If a peer chooser is registered with the same name, this list will be
// ignored.
//
// See PeerListSpec for details on how to integrate your own peer list with
// the system.
|
[
"RegisterPeerList",
"registers",
"a",
"PeerListSpec",
"with",
"the",
"given",
"Configurator",
"teaching",
"it",
"how",
"to",
"build",
"peer",
"lists",
"of",
"this",
"kind",
"from",
"configuration",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"PeerListSpec",
"is",
"invalid",
".",
"Use",
"MustRegisterPeerList",
"to",
"panic",
"in",
"the",
"case",
"of",
"registration",
"failure",
".",
"If",
"a",
"peer",
"list",
"with",
"the",
"same",
"name",
"already",
"exists",
"it",
"will",
"be",
"replaced",
".",
"If",
"a",
"peer",
"chooser",
"is",
"registered",
"with",
"the",
"same",
"name",
"this",
"list",
"will",
"be",
"ignored",
".",
"See",
"PeerListSpec",
"for",
"details",
"on",
"how",
"to",
"integrate",
"your",
"own",
"peer",
"list",
"with",
"the",
"system",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L150-L162
|
10,513 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
MustRegisterPeerList
|
func (c *Configurator) MustRegisterPeerList(s PeerListSpec) {
if err := c.RegisterPeerList(s); err != nil {
panic(err)
}
}
|
go
|
func (c *Configurator) MustRegisterPeerList(s PeerListSpec) {
if err := c.RegisterPeerList(s); err != nil {
panic(err)
}
}
|
[
"func",
"(",
"c",
"*",
"Configurator",
")",
"MustRegisterPeerList",
"(",
"s",
"PeerListSpec",
")",
"{",
"if",
"err",
":=",
"c",
".",
"RegisterPeerList",
"(",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// MustRegisterPeerList registers the given PeerListSpec with the Configurator.
// This function panics if the PeerListSpec is invalid.
|
[
"MustRegisterPeerList",
"registers",
"the",
"given",
"PeerListSpec",
"with",
"the",
"Configurator",
".",
"This",
"function",
"panics",
"if",
"the",
"PeerListSpec",
"is",
"invalid",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L166-L170
|
10,514 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
RegisterPeerListUpdater
|
func (c *Configurator) RegisterPeerListUpdater(s PeerListUpdaterSpec) error {
if s.Name == "" {
return errors.New("name is required")
}
spec, err := compilePeerListUpdaterSpec(&s)
if err != nil {
return fmt.Errorf("invalid PeerListUpdaterSpec for %q: %v", s.Name, err)
}
c.knownPeerListUpdaters[s.Name] = spec
return nil
}
|
go
|
func (c *Configurator) RegisterPeerListUpdater(s PeerListUpdaterSpec) error {
if s.Name == "" {
return errors.New("name is required")
}
spec, err := compilePeerListUpdaterSpec(&s)
if err != nil {
return fmt.Errorf("invalid PeerListUpdaterSpec for %q: %v", s.Name, err)
}
c.knownPeerListUpdaters[s.Name] = spec
return nil
}
|
[
"func",
"(",
"c",
"*",
"Configurator",
")",
"RegisterPeerListUpdater",
"(",
"s",
"PeerListUpdaterSpec",
")",
"error",
"{",
"if",
"s",
".",
"Name",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"spec",
",",
"err",
":=",
"compilePeerListUpdaterSpec",
"(",
"&",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n\n",
"c",
".",
"knownPeerListUpdaters",
"[",
"s",
".",
"Name",
"]",
"=",
"spec",
"\n",
"return",
"nil",
"\n",
"}"
] |
// RegisterPeerListUpdater registers a PeerListUpdaterSpec with the given
// Configurator, teaching it how to build peer list updaters of this kind from
// configuration.
//
// Returns an error if the PeerListUpdaterSpec is invalid. Use
// MustRegisterPeerListUpdater to panic if the registration fails.
//
// If a peer list updater with the same name already exists, it will be
// replaced.
//
// See PeerListUpdaterSpec for details on how to integrate your own peer list
// updater with the system.
|
[
"RegisterPeerListUpdater",
"registers",
"a",
"PeerListUpdaterSpec",
"with",
"the",
"given",
"Configurator",
"teaching",
"it",
"how",
"to",
"build",
"peer",
"list",
"updaters",
"of",
"this",
"kind",
"from",
"configuration",
".",
"Returns",
"an",
"error",
"if",
"the",
"PeerListUpdaterSpec",
"is",
"invalid",
".",
"Use",
"MustRegisterPeerListUpdater",
"to",
"panic",
"if",
"the",
"registration",
"fails",
".",
"If",
"a",
"peer",
"list",
"updater",
"with",
"the",
"same",
"name",
"already",
"exists",
"it",
"will",
"be",
"replaced",
".",
"See",
"PeerListUpdaterSpec",
"for",
"details",
"on",
"how",
"to",
"integrate",
"your",
"own",
"peer",
"list",
"updater",
"with",
"the",
"system",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L184-L196
|
10,515 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
MustRegisterPeerListUpdater
|
func (c *Configurator) MustRegisterPeerListUpdater(s PeerListUpdaterSpec) {
if err := c.RegisterPeerListUpdater(s); err != nil {
panic(err)
}
}
|
go
|
func (c *Configurator) MustRegisterPeerListUpdater(s PeerListUpdaterSpec) {
if err := c.RegisterPeerListUpdater(s); err != nil {
panic(err)
}
}
|
[
"func",
"(",
"c",
"*",
"Configurator",
")",
"MustRegisterPeerListUpdater",
"(",
"s",
"PeerListUpdaterSpec",
")",
"{",
"if",
"err",
":=",
"c",
".",
"RegisterPeerListUpdater",
"(",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// MustRegisterPeerListUpdater registers the given PeerListUpdaterSpec with
// the Configurator. This function panics if the PeerListUpdaterSpec is
// invalid.
|
[
"MustRegisterPeerListUpdater",
"registers",
"the",
"given",
"PeerListUpdaterSpec",
"with",
"the",
"Configurator",
".",
"This",
"function",
"panics",
"if",
"the",
"PeerListUpdaterSpec",
"is",
"invalid",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L201-L205
|
10,516 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
NewDispatcherFromYAML
|
func (c *Configurator) NewDispatcherFromYAML(serviceName string, r io.Reader) (*yarpc.Dispatcher, error) {
cfg, err := c.LoadConfigFromYAML(serviceName, r)
if err != nil {
return nil, err
}
return yarpc.NewDispatcher(cfg), nil
}
|
go
|
func (c *Configurator) NewDispatcherFromYAML(serviceName string, r io.Reader) (*yarpc.Dispatcher, error) {
cfg, err := c.LoadConfigFromYAML(serviceName, r)
if err != nil {
return nil, err
}
return yarpc.NewDispatcher(cfg), nil
}
|
[
"func",
"(",
"c",
"*",
"Configurator",
")",
"NewDispatcherFromYAML",
"(",
"serviceName",
"string",
",",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"yarpc",
".",
"Dispatcher",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"c",
".",
"LoadConfigFromYAML",
"(",
"serviceName",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"yarpc",
".",
"NewDispatcher",
"(",
"cfg",
")",
",",
"nil",
"\n",
"}"
] |
// NewDispatcherFromYAML builds a Dispatcher from the given YAML
// configuration.
|
[
"NewDispatcherFromYAML",
"builds",
"a",
"Dispatcher",
"from",
"the",
"given",
"YAML",
"configuration",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L238-L244
|
10,517 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
NewDispatcher
|
func (c *Configurator) NewDispatcher(serviceName string, data interface{}) (*yarpc.Dispatcher, error) {
cfg, err := c.LoadConfig(serviceName, data)
if err != nil {
return nil, err
}
return yarpc.NewDispatcher(cfg), nil
}
|
go
|
func (c *Configurator) NewDispatcher(serviceName string, data interface{}) (*yarpc.Dispatcher, error) {
cfg, err := c.LoadConfig(serviceName, data)
if err != nil {
return nil, err
}
return yarpc.NewDispatcher(cfg), nil
}
|
[
"func",
"(",
"c",
"*",
"Configurator",
")",
"NewDispatcher",
"(",
"serviceName",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"(",
"*",
"yarpc",
".",
"Dispatcher",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"c",
".",
"LoadConfig",
"(",
"serviceName",
",",
"data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"yarpc",
".",
"NewDispatcher",
"(",
"cfg",
")",
",",
"nil",
"\n",
"}"
] |
// NewDispatcher builds a new Dispatcher from the given configuration data.
|
[
"NewDispatcher",
"builds",
"a",
"new",
"Dispatcher",
"from",
"the",
"given",
"configuration",
"data",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L247-L253
|
10,518 |
yarpc/yarpc-go
|
yarpcconfig/configurator.go
|
spec
|
func (c *Configurator) spec(name string) (*compiledTransportSpec, error) {
spec, ok := c.knownTransports[name]
if !ok {
return nil, fmt.Errorf("unknown transport %q", name)
}
return spec, nil
}
|
go
|
func (c *Configurator) spec(name string) (*compiledTransportSpec, error) {
spec, ok := c.knownTransports[name]
if !ok {
return nil, fmt.Errorf("unknown transport %q", name)
}
return spec, nil
}
|
[
"func",
"(",
"c",
"*",
"Configurator",
")",
"spec",
"(",
"name",
"string",
")",
"(",
"*",
"compiledTransportSpec",
",",
"error",
")",
"{",
"spec",
",",
"ok",
":=",
"c",
".",
"knownTransports",
"[",
"name",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"spec",
",",
"nil",
"\n",
"}"
] |
// Returns the compiled spec for the transport with the given name or an error
|
[
"Returns",
"the",
"compiled",
"spec",
"for",
"the",
"transport",
"with",
"the",
"given",
"name",
"or",
"an",
"error"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcconfig/configurator.go#L358-L364
|
10,519 |
yarpc/yarpc-go
|
internal/crossdock/server/yarpc/phone.go
|
Phone
|
func Phone(ctx context.Context, body *PhoneRequest) (*PhoneResponse, error) {
var outbound transport.UnaryOutbound
httpTransport := http.NewTransport()
tchannelTransport, err := tchannel.NewChannelTransport(tchannel.ServiceName("yarpc-test-client"))
if err != nil {
return nil, fmt.Errorf("failed to build ChannelTransport: %v", err)
}
switch {
case body.Transport.HTTP != nil:
t := body.Transport.HTTP
outbound = httpTransport.NewSingleOutbound(fmt.Sprintf("http://%s:%d", t.Host, t.Port))
case body.Transport.TChannel != nil:
t := body.Transport.TChannel
hostport := fmt.Sprintf("%s:%d", t.Host, t.Port)
outbound = tchannelTransport.NewSingleOutbound(hostport)
default:
return nil, fmt.Errorf("unconfigured transport")
}
if err := outbound.Start(); err != nil {
return nil, err
}
defer outbound.Stop()
// TODO use yarpc.Service for caller
client := json.New(clientconfig.MultiOutbound("yarpc-test", body.Service, transport.Outbounds{
Unary: outbound,
}))
resBody := PhoneResponse{
Service: "yarpc-test", // TODO use yarpc.Service
Procedure: yarpc.CallFromContext(ctx).Procedure(),
}
ctx, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
defer cancel()
if err := client.Call(ctx, body.Procedure, body.Body, &resBody.Body); err != nil {
return nil, err
}
return &resBody, nil
}
|
go
|
func Phone(ctx context.Context, body *PhoneRequest) (*PhoneResponse, error) {
var outbound transport.UnaryOutbound
httpTransport := http.NewTransport()
tchannelTransport, err := tchannel.NewChannelTransport(tchannel.ServiceName("yarpc-test-client"))
if err != nil {
return nil, fmt.Errorf("failed to build ChannelTransport: %v", err)
}
switch {
case body.Transport.HTTP != nil:
t := body.Transport.HTTP
outbound = httpTransport.NewSingleOutbound(fmt.Sprintf("http://%s:%d", t.Host, t.Port))
case body.Transport.TChannel != nil:
t := body.Transport.TChannel
hostport := fmt.Sprintf("%s:%d", t.Host, t.Port)
outbound = tchannelTransport.NewSingleOutbound(hostport)
default:
return nil, fmt.Errorf("unconfigured transport")
}
if err := outbound.Start(); err != nil {
return nil, err
}
defer outbound.Stop()
// TODO use yarpc.Service for caller
client := json.New(clientconfig.MultiOutbound("yarpc-test", body.Service, transport.Outbounds{
Unary: outbound,
}))
resBody := PhoneResponse{
Service: "yarpc-test", // TODO use yarpc.Service
Procedure: yarpc.CallFromContext(ctx).Procedure(),
}
ctx, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
defer cancel()
if err := client.Call(ctx, body.Procedure, body.Body, &resBody.Body); err != nil {
return nil, err
}
return &resBody, nil
}
|
[
"func",
"Phone",
"(",
"ctx",
"context",
".",
"Context",
",",
"body",
"*",
"PhoneRequest",
")",
"(",
"*",
"PhoneResponse",
",",
"error",
")",
"{",
"var",
"outbound",
"transport",
".",
"UnaryOutbound",
"\n\n",
"httpTransport",
":=",
"http",
".",
"NewTransport",
"(",
")",
"\n",
"tchannelTransport",
",",
"err",
":=",
"tchannel",
".",
"NewChannelTransport",
"(",
"tchannel",
".",
"ServiceName",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"switch",
"{",
"case",
"body",
".",
"Transport",
".",
"HTTP",
"!=",
"nil",
":",
"t",
":=",
"body",
".",
"Transport",
".",
"HTTP",
"\n",
"outbound",
"=",
"httpTransport",
".",
"NewSingleOutbound",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"Host",
",",
"t",
".",
"Port",
")",
")",
"\n",
"case",
"body",
".",
"Transport",
".",
"TChannel",
"!=",
"nil",
":",
"t",
":=",
"body",
".",
"Transport",
".",
"TChannel",
"\n",
"hostport",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"Host",
",",
"t",
".",
"Port",
")",
"\n",
"outbound",
"=",
"tchannelTransport",
".",
"NewSingleOutbound",
"(",
"hostport",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"outbound",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"outbound",
".",
"Stop",
"(",
")",
"\n\n",
"// TODO use yarpc.Service for caller",
"client",
":=",
"json",
".",
"New",
"(",
"clientconfig",
".",
"MultiOutbound",
"(",
"\"",
"\"",
",",
"body",
".",
"Service",
",",
"transport",
".",
"Outbounds",
"{",
"Unary",
":",
"outbound",
",",
"}",
")",
")",
"\n",
"resBody",
":=",
"PhoneResponse",
"{",
"Service",
":",
"\"",
"\"",
",",
"// TODO use yarpc.Service",
"Procedure",
":",
"yarpc",
".",
"CallFromContext",
"(",
"ctx",
")",
".",
"Procedure",
"(",
")",
",",
"}",
"\n\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"ctx",
",",
"500",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"if",
"err",
":=",
"client",
".",
"Call",
"(",
"ctx",
",",
"body",
".",
"Procedure",
",",
"body",
".",
"Body",
",",
"&",
"resBody",
".",
"Body",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"resBody",
",",
"nil",
"\n",
"}"
] |
// Phone implements the phone procedure
|
[
"Phone",
"implements",
"the",
"phone",
"procedure"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/server/yarpc/phone.go#L71-L114
|
10,520 |
yarpc/yarpc-go
|
internal/crossdock/server/start.go
|
Start
|
func Start() {
tch.Start()
yarpc.Start()
http.Start()
apachethrift.Start()
oneway.Start()
googlegrpc.Start()
}
|
go
|
func Start() {
tch.Start()
yarpc.Start()
http.Start()
apachethrift.Start()
oneway.Start()
googlegrpc.Start()
}
|
[
"func",
"Start",
"(",
")",
"{",
"tch",
".",
"Start",
"(",
")",
"\n",
"yarpc",
".",
"Start",
"(",
")",
"\n",
"http",
".",
"Start",
"(",
")",
"\n",
"apachethrift",
".",
"Start",
"(",
")",
"\n",
"oneway",
".",
"Start",
"(",
")",
"\n",
"googlegrpc",
".",
"Start",
"(",
")",
"\n",
"}"
] |
// Start starts all required Crossdock test servers
|
[
"Start",
"starts",
"all",
"required",
"Crossdock",
"test",
"servers"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/server/start.go#L33-L40
|
10,521 |
yarpc/yarpc-go
|
internal/crossdock/server/start.go
|
Stop
|
func Stop() {
tch.Stop()
yarpc.Stop()
http.Stop()
apachethrift.Stop()
oneway.Stop()
googlegrpc.Stop()
}
|
go
|
func Stop() {
tch.Stop()
yarpc.Stop()
http.Stop()
apachethrift.Stop()
oneway.Stop()
googlegrpc.Stop()
}
|
[
"func",
"Stop",
"(",
")",
"{",
"tch",
".",
"Stop",
"(",
")",
"\n",
"yarpc",
".",
"Stop",
"(",
")",
"\n",
"http",
".",
"Stop",
"(",
")",
"\n",
"apachethrift",
".",
"Stop",
"(",
")",
"\n",
"oneway",
".",
"Stop",
"(",
")",
"\n",
"googlegrpc",
".",
"Stop",
"(",
")",
"\n",
"}"
] |
// Stop stops all required Crossdock test servers
|
[
"Stop",
"stops",
"all",
"required",
"Crossdock",
"test",
"servers"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/server/start.go#L43-L50
|
10,522 |
yarpc/yarpc-go
|
encoding/thrift/thriftrw-plugin-yarpc/template.go
|
AllFunctions
|
func (s *Svc) AllFunctions() []*api.Function {
var (
functions []*api.Function
added = make(map[string]struct{})
services = append([]*Svc{s}, s.Parents...)
)
for _, s := range services {
for _, f := range s.Functions {
if _, taken := added[f.ThriftName]; taken {
continue
}
functions = append(functions, f)
}
}
return functions
}
|
go
|
func (s *Svc) AllFunctions() []*api.Function {
var (
functions []*api.Function
added = make(map[string]struct{})
services = append([]*Svc{s}, s.Parents...)
)
for _, s := range services {
for _, f := range s.Functions {
if _, taken := added[f.ThriftName]; taken {
continue
}
functions = append(functions, f)
}
}
return functions
}
|
[
"func",
"(",
"s",
"*",
"Svc",
")",
"AllFunctions",
"(",
")",
"[",
"]",
"*",
"api",
".",
"Function",
"{",
"var",
"(",
"functions",
"[",
"]",
"*",
"api",
".",
"Function",
"\n",
"added",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"\n",
"services",
"=",
"append",
"(",
"[",
"]",
"*",
"Svc",
"{",
"s",
"}",
",",
"s",
".",
"Parents",
"...",
")",
"\n",
")",
"\n\n",
"for",
"_",
",",
"s",
":=",
"range",
"services",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"s",
".",
"Functions",
"{",
"if",
"_",
",",
"taken",
":=",
"added",
"[",
"f",
".",
"ThriftName",
"]",
";",
"taken",
"{",
"continue",
"\n",
"}",
"\n\n",
"functions",
"=",
"append",
"(",
"functions",
",",
"f",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"functions",
"\n",
"}"
] |
// AllFunctions returns a list of all functions for this service including
// inherited functions.
|
[
"AllFunctions",
"returns",
"a",
"list",
"of",
"all",
"functions",
"for",
"this",
"service",
"including",
"inherited",
"functions",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/thriftrw-plugin-yarpc/template.go#L45-L63
|
10,523 |
yarpc/yarpc-go
|
encoding/thrift/thriftrw-plugin-yarpc/template.go
|
Parent
|
func (s *Svc) Parent() *api.Service {
if len(s.Parents) > 0 {
return s.Parents[0].Service
}
return nil
}
|
go
|
func (s *Svc) Parent() *api.Service {
if len(s.Parents) > 0 {
return s.Parents[0].Service
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"Svc",
")",
"Parent",
"(",
")",
"*",
"api",
".",
"Service",
"{",
"if",
"len",
"(",
"s",
".",
"Parents",
")",
">",
"0",
"{",
"return",
"s",
".",
"Parents",
"[",
"0",
"]",
".",
"Service",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Parent returns the immediate parent of this service or nil if it doesn't
// have any.
|
[
"Parent",
"returns",
"the",
"immediate",
"parent",
"of",
"this",
"service",
"or",
"nil",
"if",
"it",
"doesn",
"t",
"have",
"any",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/thriftrw-plugin-yarpc/template.go#L67-L72
|
10,524 |
yarpc/yarpc-go
|
encoding/thrift/thriftrw-plugin-yarpc/template.go
|
ServerPackagePath
|
func (s *Svc) ServerPackagePath() string {
return fmt.Sprintf("%s/%sserver", s.Module.ImportPath, strings.ToLower(s.Name))
}
|
go
|
func (s *Svc) ServerPackagePath() string {
return fmt.Sprintf("%s/%sserver", s.Module.ImportPath, strings.ToLower(s.Name))
}
|
[
"func",
"(",
"s",
"*",
"Svc",
")",
"ServerPackagePath",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"s",
".",
"Module",
".",
"ImportPath",
",",
"strings",
".",
"ToLower",
"(",
"s",
".",
"Name",
")",
")",
"\n",
"}"
] |
// ServerPackagePath returns the import path to the server package for this
// service.
|
[
"ServerPackagePath",
"returns",
"the",
"import",
"path",
"to",
"the",
"server",
"package",
"for",
"this",
"service",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/thriftrw-plugin-yarpc/template.go#L76-L78
|
10,525 |
yarpc/yarpc-go
|
encoding/thrift/thriftrw-plugin-yarpc/template.go
|
ParentServerPackagePath
|
func (d *templateData) ParentServerPackagePath() string {
if len(d.Parents) == 0 {
return ""
}
return d.Parents[0].ServerPackagePath()
}
|
go
|
func (d *templateData) ParentServerPackagePath() string {
if len(d.Parents) == 0 {
return ""
}
return d.Parents[0].ServerPackagePath()
}
|
[
"func",
"(",
"d",
"*",
"templateData",
")",
"ParentServerPackagePath",
"(",
")",
"string",
"{",
"if",
"len",
"(",
"d",
".",
"Parents",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"d",
".",
"Parents",
"[",
"0",
"]",
".",
"ServerPackagePath",
"(",
")",
"\n",
"}"
] |
// ParentServerPackagePath returns the import path for the immediate parent
// service's YARPC server package or an empty string if this service doesn't
// extend another service.
|
[
"ParentServerPackagePath",
"returns",
"the",
"import",
"path",
"for",
"the",
"immediate",
"parent",
"service",
"s",
"YARPC",
"server",
"package",
"or",
"an",
"empty",
"string",
"if",
"this",
"service",
"doesn",
"t",
"extend",
"another",
"service",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/thriftrw-plugin-yarpc/template.go#L113-L118
|
10,526 |
yarpc/yarpc-go
|
encoding/thrift/thriftrw-plugin-yarpc/template.go
|
ParentClientPackagePath
|
func (d *templateData) ParentClientPackagePath() string {
if len(d.Parents) == 0 {
return ""
}
return d.Parents[0].ClientPackagePath()
}
|
go
|
func (d *templateData) ParentClientPackagePath() string {
if len(d.Parents) == 0 {
return ""
}
return d.Parents[0].ClientPackagePath()
}
|
[
"func",
"(",
"d",
"*",
"templateData",
")",
"ParentClientPackagePath",
"(",
")",
"string",
"{",
"if",
"len",
"(",
"d",
".",
"Parents",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"d",
".",
"Parents",
"[",
"0",
"]",
".",
"ClientPackagePath",
"(",
")",
"\n",
"}"
] |
// ParentClientPackagePath returns the import path for the immediate parent
// service's YARPC client package or an empty string if this service doesn't
// extend another service.
|
[
"ParentClientPackagePath",
"returns",
"the",
"import",
"path",
"for",
"the",
"immediate",
"parent",
"service",
"s",
"YARPC",
"client",
"package",
"or",
"an",
"empty",
"string",
"if",
"this",
"service",
"doesn",
"t",
"extend",
"another",
"service",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/thrift/thriftrw-plugin-yarpc/template.go#L123-L128
|
10,527 |
yarpc/yarpc-go
|
internal/crossdock/client/googlegrpcclient/googlegrpcclient.go
|
Run
|
func Run(t crossdock.T) {
fatals := crossdock.Fatals(t)
server := t.Param(params.Server)
fatals.NotEmpty(server, "server is required")
clientConn, err := ggrpc.Dial(fmt.Sprintf("%s:8089", server), ggrpc.WithInsecure())
fatals.NoError(err, "grpc.Dial failed")
client := crossdockpb.NewEchoClient(clientConn)
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
token := random.String(5)
pong, err := client.Echo(wrap(ctx), &crossdockpb.Ping{Beep: token})
crossdock.Fatals(t).NoError(err, "call to Echo::echo failed: %v", err)
crossdock.Assert(t).Equal(token, pong.Boop, "server said: %v", pong.Boop)
}
|
go
|
func Run(t crossdock.T) {
fatals := crossdock.Fatals(t)
server := t.Param(params.Server)
fatals.NotEmpty(server, "server is required")
clientConn, err := ggrpc.Dial(fmt.Sprintf("%s:8089", server), ggrpc.WithInsecure())
fatals.NoError(err, "grpc.Dial failed")
client := crossdockpb.NewEchoClient(clientConn)
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
token := random.String(5)
pong, err := client.Echo(wrap(ctx), &crossdockpb.Ping{Beep: token})
crossdock.Fatals(t).NoError(err, "call to Echo::echo failed: %v", err)
crossdock.Assert(t).Equal(token, pong.Boop, "server said: %v", pong.Boop)
}
|
[
"func",
"Run",
"(",
"t",
"crossdock",
".",
"T",
")",
"{",
"fatals",
":=",
"crossdock",
".",
"Fatals",
"(",
"t",
")",
"\n\n",
"server",
":=",
"t",
".",
"Param",
"(",
"params",
".",
"Server",
")",
"\n",
"fatals",
".",
"NotEmpty",
"(",
"server",
",",
"\"",
"\"",
")",
"\n\n",
"clientConn",
",",
"err",
":=",
"ggrpc",
".",
"Dial",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"server",
")",
",",
"ggrpc",
".",
"WithInsecure",
"(",
")",
")",
"\n",
"fatals",
".",
"NoError",
"(",
"err",
",",
"\"",
"\"",
")",
"\n\n",
"client",
":=",
"crossdockpb",
".",
"NewEchoClient",
"(",
"clientConn",
")",
"\n\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"context",
".",
"Background",
"(",
")",
",",
"time",
".",
"Second",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"token",
":=",
"random",
".",
"String",
"(",
"5",
")",
"\n\n",
"pong",
",",
"err",
":=",
"client",
".",
"Echo",
"(",
"wrap",
"(",
"ctx",
")",
",",
"&",
"crossdockpb",
".",
"Ping",
"{",
"Beep",
":",
"token",
"}",
")",
"\n\n",
"crossdock",
".",
"Fatals",
"(",
"t",
")",
".",
"NoError",
"(",
"err",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"crossdock",
".",
"Assert",
"(",
"t",
")",
".",
"Equal",
"(",
"token",
",",
"pong",
".",
"Boop",
",",
"\"",
"\"",
",",
"pong",
".",
"Boop",
")",
"\n",
"}"
] |
// Run tests a grpc-go call to the yarpc server.
|
[
"Run",
"tests",
"a",
"grpc",
"-",
"go",
"call",
"to",
"the",
"yarpc",
"server",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/client/googlegrpcclient/googlegrpcclient.go#L42-L62
|
10,528 |
yarpc/yarpc-go
|
introspection.go
|
Introspect
|
func (d *Dispatcher) Introspect() introspection.DispatcherStatus {
var inbounds []introspection.InboundStatus
for _, i := range d.inbounds {
var status introspection.InboundStatus
if i, ok := i.(introspection.IntrospectableInbound); ok {
status = i.Introspect()
} else {
status = introspection.InboundStatus{
Transport: "Introspection not supported",
}
}
inbounds = append(inbounds, status)
}
var outbounds []introspection.OutboundStatus
for outboundKey, o := range d.outbounds {
if o.Unary != nil {
var status introspection.OutboundStatus
if o, ok := o.Unary.(introspection.IntrospectableOutbound); ok {
status = o.Introspect()
} else {
status.Transport = "Introspection not supported"
}
status.RPCType = "unary"
status.Service = o.ServiceName
status.OutboundKey = outboundKey
outbounds = append(outbounds, status)
}
if o.Oneway != nil {
var status introspection.OutboundStatus
if o, ok := o.Oneway.(introspection.IntrospectableOutbound); ok {
status = o.Introspect()
} else {
status.Transport = "Introspection not supported"
}
status.RPCType = "oneway"
status.Service = o.ServiceName
status.OutboundKey = outboundKey
outbounds = append(outbounds, status)
}
}
procedures := introspection.IntrospectProcedures(d.table.Procedures())
return introspection.DispatcherStatus{
Name: d.name,
ID: fmt.Sprintf("%p", d),
Procedures: procedures,
Inbounds: inbounds,
Outbounds: outbounds,
PackageVersions: PackageVersions,
}
}
|
go
|
func (d *Dispatcher) Introspect() introspection.DispatcherStatus {
var inbounds []introspection.InboundStatus
for _, i := range d.inbounds {
var status introspection.InboundStatus
if i, ok := i.(introspection.IntrospectableInbound); ok {
status = i.Introspect()
} else {
status = introspection.InboundStatus{
Transport: "Introspection not supported",
}
}
inbounds = append(inbounds, status)
}
var outbounds []introspection.OutboundStatus
for outboundKey, o := range d.outbounds {
if o.Unary != nil {
var status introspection.OutboundStatus
if o, ok := o.Unary.(introspection.IntrospectableOutbound); ok {
status = o.Introspect()
} else {
status.Transport = "Introspection not supported"
}
status.RPCType = "unary"
status.Service = o.ServiceName
status.OutboundKey = outboundKey
outbounds = append(outbounds, status)
}
if o.Oneway != nil {
var status introspection.OutboundStatus
if o, ok := o.Oneway.(introspection.IntrospectableOutbound); ok {
status = o.Introspect()
} else {
status.Transport = "Introspection not supported"
}
status.RPCType = "oneway"
status.Service = o.ServiceName
status.OutboundKey = outboundKey
outbounds = append(outbounds, status)
}
}
procedures := introspection.IntrospectProcedures(d.table.Procedures())
return introspection.DispatcherStatus{
Name: d.name,
ID: fmt.Sprintf("%p", d),
Procedures: procedures,
Inbounds: inbounds,
Outbounds: outbounds,
PackageVersions: PackageVersions,
}
}
|
[
"func",
"(",
"d",
"*",
"Dispatcher",
")",
"Introspect",
"(",
")",
"introspection",
".",
"DispatcherStatus",
"{",
"var",
"inbounds",
"[",
"]",
"introspection",
".",
"InboundStatus",
"\n",
"for",
"_",
",",
"i",
":=",
"range",
"d",
".",
"inbounds",
"{",
"var",
"status",
"introspection",
".",
"InboundStatus",
"\n",
"if",
"i",
",",
"ok",
":=",
"i",
".",
"(",
"introspection",
".",
"IntrospectableInbound",
")",
";",
"ok",
"{",
"status",
"=",
"i",
".",
"Introspect",
"(",
")",
"\n",
"}",
"else",
"{",
"status",
"=",
"introspection",
".",
"InboundStatus",
"{",
"Transport",
":",
"\"",
"\"",
",",
"}",
"\n",
"}",
"\n",
"inbounds",
"=",
"append",
"(",
"inbounds",
",",
"status",
")",
"\n",
"}",
"\n",
"var",
"outbounds",
"[",
"]",
"introspection",
".",
"OutboundStatus",
"\n",
"for",
"outboundKey",
",",
"o",
":=",
"range",
"d",
".",
"outbounds",
"{",
"if",
"o",
".",
"Unary",
"!=",
"nil",
"{",
"var",
"status",
"introspection",
".",
"OutboundStatus",
"\n",
"if",
"o",
",",
"ok",
":=",
"o",
".",
"Unary",
".",
"(",
"introspection",
".",
"IntrospectableOutbound",
")",
";",
"ok",
"{",
"status",
"=",
"o",
".",
"Introspect",
"(",
")",
"\n",
"}",
"else",
"{",
"status",
".",
"Transport",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"status",
".",
"RPCType",
"=",
"\"",
"\"",
"\n",
"status",
".",
"Service",
"=",
"o",
".",
"ServiceName",
"\n",
"status",
".",
"OutboundKey",
"=",
"outboundKey",
"\n",
"outbounds",
"=",
"append",
"(",
"outbounds",
",",
"status",
")",
"\n",
"}",
"\n",
"if",
"o",
".",
"Oneway",
"!=",
"nil",
"{",
"var",
"status",
"introspection",
".",
"OutboundStatus",
"\n",
"if",
"o",
",",
"ok",
":=",
"o",
".",
"Oneway",
".",
"(",
"introspection",
".",
"IntrospectableOutbound",
")",
";",
"ok",
"{",
"status",
"=",
"o",
".",
"Introspect",
"(",
")",
"\n",
"}",
"else",
"{",
"status",
".",
"Transport",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"status",
".",
"RPCType",
"=",
"\"",
"\"",
"\n",
"status",
".",
"Service",
"=",
"o",
".",
"ServiceName",
"\n",
"status",
".",
"OutboundKey",
"=",
"outboundKey",
"\n",
"outbounds",
"=",
"append",
"(",
"outbounds",
",",
"status",
")",
"\n",
"}",
"\n",
"}",
"\n",
"procedures",
":=",
"introspection",
".",
"IntrospectProcedures",
"(",
"d",
".",
"table",
".",
"Procedures",
"(",
")",
")",
"\n",
"return",
"introspection",
".",
"DispatcherStatus",
"{",
"Name",
":",
"d",
".",
"name",
",",
"ID",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"d",
")",
",",
"Procedures",
":",
"procedures",
",",
"Inbounds",
":",
"inbounds",
",",
"Outbounds",
":",
"outbounds",
",",
"PackageVersions",
":",
"PackageVersions",
",",
"}",
"\n",
"}"
] |
// Introspect returns detailed information about the dispatcher. This function
// acquires a lots of locks throughout and should only be called with some
// reserve. This method is public merely for use by the package yarpcmeta. The
// result of this function is internal to yarpc anyway.
|
[
"Introspect",
"returns",
"detailed",
"information",
"about",
"the",
"dispatcher",
".",
"This",
"function",
"acquires",
"a",
"lots",
"of",
"locks",
"throughout",
"and",
"should",
"only",
"be",
"called",
"with",
"some",
"reserve",
".",
"This",
"method",
"is",
"public",
"merely",
"for",
"use",
"by",
"the",
"package",
"yarpcmeta",
".",
"The",
"result",
"of",
"this",
"function",
"is",
"internal",
"to",
"yarpc",
"anyway",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/introspection.go#L36-L85
|
10,529 |
yarpc/yarpc-go
|
internal/net/httpserver.go
|
NewHTTPServer
|
func NewHTTPServer(s *http.Server) *HTTPServer {
return &HTTPServer{
Server: s,
done: make(chan error, 1),
}
}
|
go
|
func NewHTTPServer(s *http.Server) *HTTPServer {
return &HTTPServer{
Server: s,
done: make(chan error, 1),
}
}
|
[
"func",
"NewHTTPServer",
"(",
"s",
"*",
"http",
".",
"Server",
")",
"*",
"HTTPServer",
"{",
"return",
"&",
"HTTPServer",
"{",
"Server",
":",
"s",
",",
"done",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
"\n",
"}"
] |
// NewHTTPServer wraps the given http.Server into an HTTPServer.
|
[
"NewHTTPServer",
"wraps",
"the",
"given",
"http",
".",
"Server",
"into",
"an",
"HTTPServer",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/net/httpserver.go#L50-L55
|
10,530 |
yarpc/yarpc-go
|
internal/net/httpserver.go
|
Listener
|
func (h *HTTPServer) Listener() net.Listener {
h.lock.RLock()
listener := h.listener
h.lock.RUnlock()
return listener
}
|
go
|
func (h *HTTPServer) Listener() net.Listener {
h.lock.RLock()
listener := h.listener
h.lock.RUnlock()
return listener
}
|
[
"func",
"(",
"h",
"*",
"HTTPServer",
")",
"Listener",
"(",
")",
"net",
".",
"Listener",
"{",
"h",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"listener",
":=",
"h",
".",
"listener",
"\n",
"h",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"listener",
"\n",
"}"
] |
// Listener returns the listener for this server or nil if the server isn't
// yet listening.
|
[
"Listener",
"returns",
"the",
"listener",
"for",
"this",
"server",
"or",
"nil",
"if",
"the",
"server",
"isn",
"t",
"yet",
"listening",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/net/httpserver.go#L59-L64
|
10,531 |
yarpc/yarpc-go
|
internal/net/httpserver.go
|
Shutdown
|
func (h *HTTPServer) Shutdown(ctx context.Context) error {
if h.stopped.Swap(true) {
return nil
}
wasRunning, closeErr := h.shutdownServer(ctx)
if !wasRunning {
return nil
}
serveErr := <-h.done // wait until Serve() stops
if closeErr != nil {
return closeErr
}
return serveErr
}
|
go
|
func (h *HTTPServer) Shutdown(ctx context.Context) error {
if h.stopped.Swap(true) {
return nil
}
wasRunning, closeErr := h.shutdownServer(ctx)
if !wasRunning {
return nil
}
serveErr := <-h.done // wait until Serve() stops
if closeErr != nil {
return closeErr
}
return serveErr
}
|
[
"func",
"(",
"h",
"*",
"HTTPServer",
")",
"Shutdown",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"h",
".",
"stopped",
".",
"Swap",
"(",
"true",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"wasRunning",
",",
"closeErr",
":=",
"h",
".",
"shutdownServer",
"(",
"ctx",
")",
"\n",
"if",
"!",
"wasRunning",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"serveErr",
":=",
"<-",
"h",
".",
"done",
"// wait until Serve() stops",
"\n",
"if",
"closeErr",
"!=",
"nil",
"{",
"return",
"closeErr",
"\n",
"}",
"\n",
"return",
"serveErr",
"\n",
"}"
] |
// Shutdown stops the server. An error is returned if the server stopped
// unexpectedly.
//
// Once a server is stopped, it cannot be started again with ListenAndServe.
|
[
"Shutdown",
"stops",
"the",
"server",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"server",
"stopped",
"unexpectedly",
".",
"Once",
"a",
"server",
"is",
"stopped",
"it",
"cannot",
"be",
"started",
"again",
"with",
"ListenAndServe",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/net/httpserver.go#L114-L129
|
10,532 |
yarpc/yarpc-go
|
transport/grpc/dialer.go
|
NewDialer
|
func (t *Transport) NewDialer(options ...DialOption) *Dialer {
return &Dialer{trans: t, options: newDialOptions(options)}
}
|
go
|
func (t *Transport) NewDialer(options ...DialOption) *Dialer {
return &Dialer{trans: t, options: newDialOptions(options)}
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"NewDialer",
"(",
"options",
"...",
"DialOption",
")",
"*",
"Dialer",
"{",
"return",
"&",
"Dialer",
"{",
"trans",
":",
"t",
",",
"options",
":",
"newDialOptions",
"(",
"options",
")",
"}",
"\n",
"}"
] |
// NewDialer creates a transport that is decorated to retain peers with
// additional gRPC dial options.
|
[
"NewDialer",
"creates",
"a",
"transport",
"that",
"is",
"decorated",
"to",
"retain",
"peers",
"with",
"additional",
"gRPC",
"dial",
"options",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/grpc/dialer.go#L29-L31
|
10,533 |
yarpc/yarpc-go
|
transport/grpc/dialer.go
|
RetainPeer
|
func (d *Dialer) RetainPeer(id peer.Identifier, ps peer.Subscriber) (peer.Peer, error) {
return d.trans.retainPeer(id, d.options, ps)
}
|
go
|
func (d *Dialer) RetainPeer(id peer.Identifier, ps peer.Subscriber) (peer.Peer, error) {
return d.trans.retainPeer(id, d.options, ps)
}
|
[
"func",
"(",
"d",
"*",
"Dialer",
")",
"RetainPeer",
"(",
"id",
"peer",
".",
"Identifier",
",",
"ps",
"peer",
".",
"Subscriber",
")",
"(",
"peer",
".",
"Peer",
",",
"error",
")",
"{",
"return",
"d",
".",
"trans",
".",
"retainPeer",
"(",
"id",
",",
"d",
".",
"options",
",",
"ps",
")",
"\n",
"}"
] |
// RetainPeer retains the identified peer, passing dial options.
|
[
"RetainPeer",
"retains",
"the",
"identified",
"peer",
"passing",
"dial",
"options",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/grpc/dialer.go#L43-L45
|
10,534 |
yarpc/yarpc-go
|
transport/grpc/dialer.go
|
ReleasePeer
|
func (d *Dialer) ReleasePeer(id peer.Identifier, ps peer.Subscriber) error {
return d.trans.ReleasePeer(id, ps)
}
|
go
|
func (d *Dialer) ReleasePeer(id peer.Identifier, ps peer.Subscriber) error {
return d.trans.ReleasePeer(id, ps)
}
|
[
"func",
"(",
"d",
"*",
"Dialer",
")",
"ReleasePeer",
"(",
"id",
"peer",
".",
"Identifier",
",",
"ps",
"peer",
".",
"Subscriber",
")",
"error",
"{",
"return",
"d",
".",
"trans",
".",
"ReleasePeer",
"(",
"id",
",",
"ps",
")",
"\n",
"}"
] |
// ReleasePeer releases the identified peer.
|
[
"ReleasePeer",
"releases",
"the",
"identified",
"peer",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/grpc/dialer.go#L48-L50
|
10,535 |
yarpc/yarpc-go
|
internal/examples/protobuf/example/example.go
|
GetValue
|
func (k *KeyValueYARPCServer) GetValue(ctx context.Context, request *examplepb.GetValueRequest) (*examplepb.GetValueResponse, error) {
if request == nil {
return nil, errRequestNil
}
if request.Key == "" {
return nil, errRequestKeyNil
}
k.RLock()
if value, ok := k.items[request.Key]; ok {
k.RUnlock()
var nextError error
k.Lock()
if k.nextError != nil {
nextError = k.nextError
k.nextError = nil
}
k.Unlock()
return &examplepb.GetValueResponse{Value: value}, nextError
}
k.RUnlock()
return nil, yarpcerrors.Newf(yarpcerrors.CodeNotFound, request.Key)
}
|
go
|
func (k *KeyValueYARPCServer) GetValue(ctx context.Context, request *examplepb.GetValueRequest) (*examplepb.GetValueResponse, error) {
if request == nil {
return nil, errRequestNil
}
if request.Key == "" {
return nil, errRequestKeyNil
}
k.RLock()
if value, ok := k.items[request.Key]; ok {
k.RUnlock()
var nextError error
k.Lock()
if k.nextError != nil {
nextError = k.nextError
k.nextError = nil
}
k.Unlock()
return &examplepb.GetValueResponse{Value: value}, nextError
}
k.RUnlock()
return nil, yarpcerrors.Newf(yarpcerrors.CodeNotFound, request.Key)
}
|
[
"func",
"(",
"k",
"*",
"KeyValueYARPCServer",
")",
"GetValue",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"examplepb",
".",
"GetValueRequest",
")",
"(",
"*",
"examplepb",
".",
"GetValueResponse",
",",
"error",
")",
"{",
"if",
"request",
"==",
"nil",
"{",
"return",
"nil",
",",
"errRequestNil",
"\n",
"}",
"\n",
"if",
"request",
".",
"Key",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errRequestKeyNil",
"\n",
"}",
"\n",
"k",
".",
"RLock",
"(",
")",
"\n",
"if",
"value",
",",
"ok",
":=",
"k",
".",
"items",
"[",
"request",
".",
"Key",
"]",
";",
"ok",
"{",
"k",
".",
"RUnlock",
"(",
")",
"\n",
"var",
"nextError",
"error",
"\n",
"k",
".",
"Lock",
"(",
")",
"\n",
"if",
"k",
".",
"nextError",
"!=",
"nil",
"{",
"nextError",
"=",
"k",
".",
"nextError",
"\n",
"k",
".",
"nextError",
"=",
"nil",
"\n",
"}",
"\n",
"k",
".",
"Unlock",
"(",
")",
"\n",
"return",
"&",
"examplepb",
".",
"GetValueResponse",
"{",
"Value",
":",
"value",
"}",
",",
"nextError",
"\n",
"}",
"\n",
"k",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"nil",
",",
"yarpcerrors",
".",
"Newf",
"(",
"yarpcerrors",
".",
"CodeNotFound",
",",
"request",
".",
"Key",
")",
"\n",
"}"
] |
// GetValue implements GetValue.
|
[
"GetValue",
"implements",
"GetValue",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/example/example.go#L63-L84
|
10,536 |
yarpc/yarpc-go
|
internal/examples/protobuf/example/example.go
|
SetValue
|
func (k *KeyValueYARPCServer) SetValue(ctx context.Context, request *examplepb.SetValueRequest) (*examplepb.SetValueResponse, error) {
if request == nil {
return nil, errRequestNil
}
if request.Key == "" {
return nil, errRequestKeyNil
}
k.Lock()
if request.Value == "" {
delete(k.items, request.Key)
} else {
k.items[request.Key] = request.Value
}
var nextError error
if k.nextError != nil {
nextError = k.nextError
k.nextError = nil
}
k.Unlock()
return nil, nextError
}
|
go
|
func (k *KeyValueYARPCServer) SetValue(ctx context.Context, request *examplepb.SetValueRequest) (*examplepb.SetValueResponse, error) {
if request == nil {
return nil, errRequestNil
}
if request.Key == "" {
return nil, errRequestKeyNil
}
k.Lock()
if request.Value == "" {
delete(k.items, request.Key)
} else {
k.items[request.Key] = request.Value
}
var nextError error
if k.nextError != nil {
nextError = k.nextError
k.nextError = nil
}
k.Unlock()
return nil, nextError
}
|
[
"func",
"(",
"k",
"*",
"KeyValueYARPCServer",
")",
"SetValue",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"examplepb",
".",
"SetValueRequest",
")",
"(",
"*",
"examplepb",
".",
"SetValueResponse",
",",
"error",
")",
"{",
"if",
"request",
"==",
"nil",
"{",
"return",
"nil",
",",
"errRequestNil",
"\n",
"}",
"\n",
"if",
"request",
".",
"Key",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errRequestKeyNil",
"\n",
"}",
"\n",
"k",
".",
"Lock",
"(",
")",
"\n",
"if",
"request",
".",
"Value",
"==",
"\"",
"\"",
"{",
"delete",
"(",
"k",
".",
"items",
",",
"request",
".",
"Key",
")",
"\n",
"}",
"else",
"{",
"k",
".",
"items",
"[",
"request",
".",
"Key",
"]",
"=",
"request",
".",
"Value",
"\n",
"}",
"\n",
"var",
"nextError",
"error",
"\n",
"if",
"k",
".",
"nextError",
"!=",
"nil",
"{",
"nextError",
"=",
"k",
".",
"nextError",
"\n",
"k",
".",
"nextError",
"=",
"nil",
"\n",
"}",
"\n",
"k",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
",",
"nextError",
"\n",
"}"
] |
// SetValue implements SetValue.
|
[
"SetValue",
"implements",
"SetValue",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/example/example.go#L87-L107
|
10,537 |
yarpc/yarpc-go
|
internal/examples/protobuf/example/example.go
|
SetNextError
|
func (k *KeyValueYARPCServer) SetNextError(err error) {
k.Lock()
defer k.Unlock()
k.nextError = err
}
|
go
|
func (k *KeyValueYARPCServer) SetNextError(err error) {
k.Lock()
defer k.Unlock()
k.nextError = err
}
|
[
"func",
"(",
"k",
"*",
"KeyValueYARPCServer",
")",
"SetNextError",
"(",
"err",
"error",
")",
"{",
"k",
".",
"Lock",
"(",
")",
"\n",
"defer",
"k",
".",
"Unlock",
"(",
")",
"\n",
"k",
".",
"nextError",
"=",
"err",
"\n",
"}"
] |
// SetNextError sets the error to return on the next call to KeyValueYARPCServer.
|
[
"SetNextError",
"sets",
"the",
"error",
"to",
"return",
"on",
"the",
"next",
"call",
"to",
"KeyValueYARPCServer",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/example/example.go#L110-L114
|
10,538 |
yarpc/yarpc-go
|
internal/examples/protobuf/example/example.go
|
NewSinkYARPCServer
|
func NewSinkYARPCServer(withFireDone bool) *SinkYARPCServer {
var fireDone chan struct{}
if withFireDone {
fireDone = make(chan struct{})
}
return &SinkYARPCServer{sync.RWMutex{}, make([]string, 0), fireDone}
}
|
go
|
func NewSinkYARPCServer(withFireDone bool) *SinkYARPCServer {
var fireDone chan struct{}
if withFireDone {
fireDone = make(chan struct{})
}
return &SinkYARPCServer{sync.RWMutex{}, make([]string, 0), fireDone}
}
|
[
"func",
"NewSinkYARPCServer",
"(",
"withFireDone",
"bool",
")",
"*",
"SinkYARPCServer",
"{",
"var",
"fireDone",
"chan",
"struct",
"{",
"}",
"\n",
"if",
"withFireDone",
"{",
"fireDone",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"}",
"\n",
"return",
"&",
"SinkYARPCServer",
"{",
"sync",
".",
"RWMutex",
"{",
"}",
",",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
",",
"fireDone",
"}",
"\n",
"}"
] |
// NewSinkYARPCServer returns a new SinkYARPCServer.
|
[
"NewSinkYARPCServer",
"returns",
"a",
"new",
"SinkYARPCServer",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/example/example.go#L124-L130
|
10,539 |
yarpc/yarpc-go
|
internal/examples/protobuf/example/example.go
|
Fire
|
func (s *SinkYARPCServer) Fire(ctx context.Context, request *examplepb.FireRequest) error {
if request == nil {
return errRequestNil
}
if request.Value == "" {
return errRequestValueNil
}
s.Lock()
s.values = append(s.values, request.Value)
s.Unlock()
if s.fireDone == nil {
return nil
}
select {
case s.fireDone <- struct{}{}:
case <-time.After(FireDoneTimeout):
return yarpcerrors.Newf(yarpcerrors.CodeDeadlineExceeded, "fire done not handled after %v", FireDoneTimeout)
}
return nil
}
|
go
|
func (s *SinkYARPCServer) Fire(ctx context.Context, request *examplepb.FireRequest) error {
if request == nil {
return errRequestNil
}
if request.Value == "" {
return errRequestValueNil
}
s.Lock()
s.values = append(s.values, request.Value)
s.Unlock()
if s.fireDone == nil {
return nil
}
select {
case s.fireDone <- struct{}{}:
case <-time.After(FireDoneTimeout):
return yarpcerrors.Newf(yarpcerrors.CodeDeadlineExceeded, "fire done not handled after %v", FireDoneTimeout)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"SinkYARPCServer",
")",
"Fire",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"examplepb",
".",
"FireRequest",
")",
"error",
"{",
"if",
"request",
"==",
"nil",
"{",
"return",
"errRequestNil",
"\n",
"}",
"\n",
"if",
"request",
".",
"Value",
"==",
"\"",
"\"",
"{",
"return",
"errRequestValueNil",
"\n",
"}",
"\n",
"s",
".",
"Lock",
"(",
")",
"\n",
"s",
".",
"values",
"=",
"append",
"(",
"s",
".",
"values",
",",
"request",
".",
"Value",
")",
"\n",
"s",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
".",
"fireDone",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"select",
"{",
"case",
"s",
".",
"fireDone",
"<-",
"struct",
"{",
"}",
"{",
"}",
":",
"case",
"<-",
"time",
".",
"After",
"(",
"FireDoneTimeout",
")",
":",
"return",
"yarpcerrors",
".",
"Newf",
"(",
"yarpcerrors",
".",
"CodeDeadlineExceeded",
",",
"\"",
"\"",
",",
"FireDoneTimeout",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Fire implements Fire.
|
[
"Fire",
"implements",
"Fire",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/example/example.go#L133-L152
|
10,540 |
yarpc/yarpc-go
|
internal/examples/protobuf/example/example.go
|
Values
|
func (s *SinkYARPCServer) Values() []string {
s.RLock()
values := make([]string, len(s.values))
copy(values, s.values)
s.RUnlock()
return values
}
|
go
|
func (s *SinkYARPCServer) Values() []string {
s.RLock()
values := make([]string, len(s.values))
copy(values, s.values)
s.RUnlock()
return values
}
|
[
"func",
"(",
"s",
"*",
"SinkYARPCServer",
")",
"Values",
"(",
")",
"[",
"]",
"string",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
"values",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"s",
".",
"values",
")",
")",
"\n",
"copy",
"(",
"values",
",",
"s",
".",
"values",
")",
"\n",
"s",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"values",
"\n",
"}"
] |
// Values returns a copy of the values that have been fired.
|
[
"Values",
"returns",
"a",
"copy",
"of",
"the",
"values",
"that",
"have",
"been",
"fired",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/example/example.go#L155-L161
|
10,541 |
yarpc/yarpc-go
|
internal/examples/protobuf/example/example.go
|
WaitFireDone
|
func (s *SinkYARPCServer) WaitFireDone() error {
if s.fireDone == nil {
return nil
}
select {
case <-s.fireDone:
case <-time.After(FireDoneTimeout):
return yarpcerrors.Newf(yarpcerrors.CodeDeadlineExceeded, "fire not done after %v", FireDoneTimeout)
}
return nil
}
|
go
|
func (s *SinkYARPCServer) WaitFireDone() error {
if s.fireDone == nil {
return nil
}
select {
case <-s.fireDone:
case <-time.After(FireDoneTimeout):
return yarpcerrors.Newf(yarpcerrors.CodeDeadlineExceeded, "fire not done after %v", FireDoneTimeout)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"SinkYARPCServer",
")",
"WaitFireDone",
"(",
")",
"error",
"{",
"if",
"s",
".",
"fireDone",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"select",
"{",
"case",
"<-",
"s",
".",
"fireDone",
":",
"case",
"<-",
"time",
".",
"After",
"(",
"FireDoneTimeout",
")",
":",
"return",
"yarpcerrors",
".",
"Newf",
"(",
"yarpcerrors",
".",
"CodeDeadlineExceeded",
",",
"\"",
"\"",
",",
"FireDoneTimeout",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// WaitFireDone blocks until a fire is done, if withFireDone is set.
//
// If will timeout after FireDoneTimeout and return error.
|
[
"WaitFireDone",
"blocks",
"until",
"a",
"fire",
"is",
"done",
"if",
"withFireDone",
"is",
"set",
".",
"If",
"will",
"timeout",
"after",
"FireDoneTimeout",
"and",
"return",
"error",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/example/example.go#L166-L176
|
10,542 |
yarpc/yarpc-go
|
internal/examples/protobuf/example/example.go
|
EchoOut
|
func (f *FooYARPCServer) EchoOut(server examplepb.FooServiceEchoOutYARPCServer) (*examplepb.EchoOutResponse, error) {
var allMessages []string
call := yarpc.CallFromContext(server.Context())
for k, v := range f.expectedHeaders.Items() {
if call.Header(k) != v {
return nil, yarpcerrors.InvalidArgumentErrorf("did not receive proper headers, missing %q:%q", k, v)
}
}
for request, err := server.Recv(); err != io.EOF; request, err = server.Recv() {
if err != nil {
return nil, err
}
if request == nil {
return nil, errRequestNil
}
if request.Message == "" {
return nil, errRequestMessageNil
}
allMessages = append(allMessages, request.Message)
}
return &examplepb.EchoOutResponse{
AllMessages: allMessages,
}, nil
}
|
go
|
func (f *FooYARPCServer) EchoOut(server examplepb.FooServiceEchoOutYARPCServer) (*examplepb.EchoOutResponse, error) {
var allMessages []string
call := yarpc.CallFromContext(server.Context())
for k, v := range f.expectedHeaders.Items() {
if call.Header(k) != v {
return nil, yarpcerrors.InvalidArgumentErrorf("did not receive proper headers, missing %q:%q", k, v)
}
}
for request, err := server.Recv(); err != io.EOF; request, err = server.Recv() {
if err != nil {
return nil, err
}
if request == nil {
return nil, errRequestNil
}
if request.Message == "" {
return nil, errRequestMessageNil
}
allMessages = append(allMessages, request.Message)
}
return &examplepb.EchoOutResponse{
AllMessages: allMessages,
}, nil
}
|
[
"func",
"(",
"f",
"*",
"FooYARPCServer",
")",
"EchoOut",
"(",
"server",
"examplepb",
".",
"FooServiceEchoOutYARPCServer",
")",
"(",
"*",
"examplepb",
".",
"EchoOutResponse",
",",
"error",
")",
"{",
"var",
"allMessages",
"[",
"]",
"string",
"\n",
"call",
":=",
"yarpc",
".",
"CallFromContext",
"(",
"server",
".",
"Context",
"(",
")",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"f",
".",
"expectedHeaders",
".",
"Items",
"(",
")",
"{",
"if",
"call",
".",
"Header",
"(",
"k",
")",
"!=",
"v",
"{",
"return",
"nil",
",",
"yarpcerrors",
".",
"InvalidArgumentErrorf",
"(",
"\"",
"\"",
",",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"request",
",",
"err",
":=",
"server",
".",
"Recv",
"(",
")",
";",
"err",
"!=",
"io",
".",
"EOF",
";",
"request",
",",
"err",
"=",
"server",
".",
"Recv",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"request",
"==",
"nil",
"{",
"return",
"nil",
",",
"errRequestNil",
"\n",
"}",
"\n",
"if",
"request",
".",
"Message",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errRequestMessageNil",
"\n",
"}",
"\n",
"allMessages",
"=",
"append",
"(",
"allMessages",
",",
"request",
".",
"Message",
")",
"\n",
"}",
"\n",
"return",
"&",
"examplepb",
".",
"EchoOutResponse",
"{",
"AllMessages",
":",
"allMessages",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// EchoOut reads from a stream and echos all requests in the response.
|
[
"EchoOut",
"reads",
"from",
"a",
"stream",
"and",
"echos",
"all",
"requests",
"in",
"the",
"response",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/example/example.go#L191-L214
|
10,543 |
yarpc/yarpc-go
|
internal/examples/protobuf/example/example.go
|
EchoIn
|
func (f *FooYARPCServer) EchoIn(request *examplepb.EchoInRequest, server examplepb.FooServiceEchoInYARPCServer) error {
if request == nil {
return errRequestNil
}
if request.Message == "" {
return errRequestMessageNil
}
if request.NumResponses == 0 {
return errRequestNumResponsesNil
}
call := yarpc.CallFromContext(server.Context())
for k, v := range f.expectedHeaders.Items() {
if call.Header(k) != v {
return yarpcerrors.InvalidArgumentErrorf("did not receive proper headers, missing %q:%q", k, v)
}
}
for i := 0; i < int(request.NumResponses); i++ {
if err := server.Send(&examplepb.EchoInResponse{Message: request.Message}); err != nil {
return err
}
}
return nil
}
|
go
|
func (f *FooYARPCServer) EchoIn(request *examplepb.EchoInRequest, server examplepb.FooServiceEchoInYARPCServer) error {
if request == nil {
return errRequestNil
}
if request.Message == "" {
return errRequestMessageNil
}
if request.NumResponses == 0 {
return errRequestNumResponsesNil
}
call := yarpc.CallFromContext(server.Context())
for k, v := range f.expectedHeaders.Items() {
if call.Header(k) != v {
return yarpcerrors.InvalidArgumentErrorf("did not receive proper headers, missing %q:%q", k, v)
}
}
for i := 0; i < int(request.NumResponses); i++ {
if err := server.Send(&examplepb.EchoInResponse{Message: request.Message}); err != nil {
return err
}
}
return nil
}
|
[
"func",
"(",
"f",
"*",
"FooYARPCServer",
")",
"EchoIn",
"(",
"request",
"*",
"examplepb",
".",
"EchoInRequest",
",",
"server",
"examplepb",
".",
"FooServiceEchoInYARPCServer",
")",
"error",
"{",
"if",
"request",
"==",
"nil",
"{",
"return",
"errRequestNil",
"\n",
"}",
"\n",
"if",
"request",
".",
"Message",
"==",
"\"",
"\"",
"{",
"return",
"errRequestMessageNil",
"\n",
"}",
"\n",
"if",
"request",
".",
"NumResponses",
"==",
"0",
"{",
"return",
"errRequestNumResponsesNil",
"\n",
"}",
"\n",
"call",
":=",
"yarpc",
".",
"CallFromContext",
"(",
"server",
".",
"Context",
"(",
")",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"f",
".",
"expectedHeaders",
".",
"Items",
"(",
")",
"{",
"if",
"call",
".",
"Header",
"(",
"k",
")",
"!=",
"v",
"{",
"return",
"yarpcerrors",
".",
"InvalidArgumentErrorf",
"(",
"\"",
"\"",
",",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"int",
"(",
"request",
".",
"NumResponses",
")",
";",
"i",
"++",
"{",
"if",
"err",
":=",
"server",
".",
"Send",
"(",
"&",
"examplepb",
".",
"EchoInResponse",
"{",
"Message",
":",
"request",
".",
"Message",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// EchoIn echos a series of requests back on a stream.
|
[
"EchoIn",
"echos",
"a",
"series",
"of",
"requests",
"back",
"on",
"a",
"stream",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/example/example.go#L217-L239
|
10,544 |
yarpc/yarpc-go
|
internal/examples/protobuf/example/example.go
|
EchoBoth
|
func (f *FooYARPCServer) EchoBoth(server examplepb.FooServiceEchoBothYARPCServer) error {
call := yarpc.CallFromContext(server.Context())
for k, v := range f.expectedHeaders.Items() {
if call.Header(k) != v {
return yarpcerrors.InvalidArgumentErrorf("did not receive proper headers, missing %q:%q", k, v)
}
}
for request, err := server.Recv(); err != io.EOF; request, err = server.Recv() {
if err != nil {
return err
}
if request == nil {
return errRequestNil
}
if request.Message == "" {
return errRequestMessageNil
}
if request.NumResponses == 0 {
return errRequestNumResponsesNil
}
for i := 0; i < int(request.NumResponses); i++ {
if err := server.Send(&examplepb.EchoBothResponse{Message: request.Message}); err != nil {
return err
}
}
}
return nil
}
|
go
|
func (f *FooYARPCServer) EchoBoth(server examplepb.FooServiceEchoBothYARPCServer) error {
call := yarpc.CallFromContext(server.Context())
for k, v := range f.expectedHeaders.Items() {
if call.Header(k) != v {
return yarpcerrors.InvalidArgumentErrorf("did not receive proper headers, missing %q:%q", k, v)
}
}
for request, err := server.Recv(); err != io.EOF; request, err = server.Recv() {
if err != nil {
return err
}
if request == nil {
return errRequestNil
}
if request.Message == "" {
return errRequestMessageNil
}
if request.NumResponses == 0 {
return errRequestNumResponsesNil
}
for i := 0; i < int(request.NumResponses); i++ {
if err := server.Send(&examplepb.EchoBothResponse{Message: request.Message}); err != nil {
return err
}
}
}
return nil
}
|
[
"func",
"(",
"f",
"*",
"FooYARPCServer",
")",
"EchoBoth",
"(",
"server",
"examplepb",
".",
"FooServiceEchoBothYARPCServer",
")",
"error",
"{",
"call",
":=",
"yarpc",
".",
"CallFromContext",
"(",
"server",
".",
"Context",
"(",
")",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"f",
".",
"expectedHeaders",
".",
"Items",
"(",
")",
"{",
"if",
"call",
".",
"Header",
"(",
"k",
")",
"!=",
"v",
"{",
"return",
"yarpcerrors",
".",
"InvalidArgumentErrorf",
"(",
"\"",
"\"",
",",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"request",
",",
"err",
":=",
"server",
".",
"Recv",
"(",
")",
";",
"err",
"!=",
"io",
".",
"EOF",
";",
"request",
",",
"err",
"=",
"server",
".",
"Recv",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"request",
"==",
"nil",
"{",
"return",
"errRequestNil",
"\n",
"}",
"\n",
"if",
"request",
".",
"Message",
"==",
"\"",
"\"",
"{",
"return",
"errRequestMessageNil",
"\n",
"}",
"\n",
"if",
"request",
".",
"NumResponses",
"==",
"0",
"{",
"return",
"errRequestNumResponsesNil",
"\n",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"int",
"(",
"request",
".",
"NumResponses",
")",
";",
"i",
"++",
"{",
"if",
"err",
":=",
"server",
".",
"Send",
"(",
"&",
"examplepb",
".",
"EchoBothResponse",
"{",
"Message",
":",
"request",
".",
"Message",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// EchoBoth immediately echos a request back to the client.
|
[
"EchoBoth",
"immediately",
"echos",
"a",
"request",
"back",
"to",
"the",
"client",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/example/example.go#L242-L269
|
10,545 |
yarpc/yarpc-go
|
transport/tchannel/outbound.go
|
NewOutbound
|
func (t *Transport) NewOutbound(chooser peer.Chooser) *Outbound {
return &Outbound{
once: lifecycle.NewOnce(),
transport: t,
chooser: chooser,
}
}
|
go
|
func (t *Transport) NewOutbound(chooser peer.Chooser) *Outbound {
return &Outbound{
once: lifecycle.NewOnce(),
transport: t,
chooser: chooser,
}
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"NewOutbound",
"(",
"chooser",
"peer",
".",
"Chooser",
")",
"*",
"Outbound",
"{",
"return",
"&",
"Outbound",
"{",
"once",
":",
"lifecycle",
".",
"NewOnce",
"(",
")",
",",
"transport",
":",
"t",
",",
"chooser",
":",
"chooser",
",",
"}",
"\n",
"}"
] |
// NewOutbound builds a new TChannel outbound that selects a peer for each
// request using the given peer chooser.
|
[
"NewOutbound",
"builds",
"a",
"new",
"TChannel",
"outbound",
"that",
"selects",
"a",
"peer",
"for",
"each",
"request",
"using",
"the",
"given",
"peer",
"chooser",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/tchannel/outbound.go#L56-L62
|
10,546 |
yarpc/yarpc-go
|
transport/tchannel/outbound.go
|
NewSingleOutbound
|
func (t *Transport) NewSingleOutbound(addr string) *Outbound {
chooser := peerchooser.NewSingle(hostport.PeerIdentifier(addr), t)
return t.NewOutbound(chooser)
}
|
go
|
func (t *Transport) NewSingleOutbound(addr string) *Outbound {
chooser := peerchooser.NewSingle(hostport.PeerIdentifier(addr), t)
return t.NewOutbound(chooser)
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"NewSingleOutbound",
"(",
"addr",
"string",
")",
"*",
"Outbound",
"{",
"chooser",
":=",
"peerchooser",
".",
"NewSingle",
"(",
"hostport",
".",
"PeerIdentifier",
"(",
"addr",
")",
",",
"t",
")",
"\n",
"return",
"t",
".",
"NewOutbound",
"(",
"chooser",
")",
"\n",
"}"
] |
// NewSingleOutbound builds a new TChannel outbound always using the peer with
// the given address.
|
[
"NewSingleOutbound",
"builds",
"a",
"new",
"TChannel",
"outbound",
"always",
"using",
"the",
"peer",
"with",
"the",
"given",
"address",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/tchannel/outbound.go#L66-L69
|
10,547 |
yarpc/yarpc-go
|
transport/tchannel/outbound.go
|
Call
|
func (p *tchannelPeer) Call(ctx context.Context, req *transport.Request) (*transport.Response, error) {
root := p.transport.ch.RootPeers()
tp := root.GetOrAdd(p.HostPort())
return callWithPeer(ctx, req, tp, p.transport.headerCase)
}
|
go
|
func (p *tchannelPeer) Call(ctx context.Context, req *transport.Request) (*transport.Response, error) {
root := p.transport.ch.RootPeers()
tp := root.GetOrAdd(p.HostPort())
return callWithPeer(ctx, req, tp, p.transport.headerCase)
}
|
[
"func",
"(",
"p",
"*",
"tchannelPeer",
")",
"Call",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"transport",
".",
"Request",
")",
"(",
"*",
"transport",
".",
"Response",
",",
"error",
")",
"{",
"root",
":=",
"p",
".",
"transport",
".",
"ch",
".",
"RootPeers",
"(",
")",
"\n",
"tp",
":=",
"root",
".",
"GetOrAdd",
"(",
"p",
".",
"HostPort",
"(",
")",
")",
"\n",
"return",
"callWithPeer",
"(",
"ctx",
",",
"req",
",",
"tp",
",",
"p",
".",
"transport",
".",
"headerCase",
")",
"\n",
"}"
] |
// Call sends an RPC to this specific peer.
|
[
"Call",
"sends",
"an",
"RPC",
"to",
"this",
"specific",
"peer",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/tchannel/outbound.go#L97-L101
|
10,548 |
yarpc/yarpc-go
|
transport/tchannel/outbound.go
|
callWithPeer
|
func callWithPeer(ctx context.Context, req *transport.Request, peer *tchannel.Peer, headerCase headerCase) (*transport.Response, error) {
// NB(abg): Under the current API, the local service's name is required
// twice: once when constructing the TChannel and then again when
// constructing the RPC.
var call *tchannel.OutboundCall
var err error
format := tchannel.Format(req.Encoding)
callOptions := tchannel.CallOptions{
Format: format,
ShardKey: req.ShardKey,
RoutingKey: req.RoutingKey,
RoutingDelegate: req.RoutingDelegate,
}
// If the hostport is given, we use the BeginCall on the channel
// instead of the subchannel.
call, err = peer.BeginCall(
// TODO(abg): Set TimeoutPerAttempt in the context's retry options if
// TTL is set.
// (kris): Consider instead moving TimeoutPerAttempt to an outer
// layer, just clamp the context on outbound call.
ctx,
req.Service,
req.Procedure,
&callOptions,
)
if err != nil {
return nil, err
}
reqHeaders := headerMap(req.Headers, headerCase)
// baggage headers are transport implementation details that are stripped out (and stored in the context). Users don't interact with it
tracingBaggage := tchannel.InjectOutboundSpan(call.Response(), nil)
if err := writeHeaders(format, reqHeaders, tracingBaggage, call.Arg2Writer); err != nil {
// TODO(abg): This will wrap IO errors while writing headers as encode
// errors. We should fix that.
return nil, errors.RequestHeadersEncodeError(req, err)
}
if err := writeBody(req.Body, call); err != nil {
return nil, err
}
res := call.Response()
headers, err := readHeaders(format, res.Arg2Reader)
if err != nil {
if err, ok := err.(tchannel.SystemError); ok {
return nil, fromSystemError(err)
}
// TODO(abg): This will wrap IO errors while reading headers as decode
// errors. We should fix that.
return nil, errors.ResponseHeadersDecodeError(req, err)
}
resBody, err := res.Arg3Reader()
if err != nil {
if err, ok := err.(tchannel.SystemError); ok {
return nil, fromSystemError(err)
}
return nil, err
}
respService, _ := headers.Get(ServiceHeaderKey) // validateServiceName handles empty strings
if err := validateServiceName(req.Service, respService); err != nil {
return nil, err
}
err = getResponseError(headers)
deleteReservedHeaders(headers)
resp := &transport.Response{
Headers: headers,
Body: resBody,
ApplicationError: res.ApplicationError(),
}
return resp, err
}
|
go
|
func callWithPeer(ctx context.Context, req *transport.Request, peer *tchannel.Peer, headerCase headerCase) (*transport.Response, error) {
// NB(abg): Under the current API, the local service's name is required
// twice: once when constructing the TChannel and then again when
// constructing the RPC.
var call *tchannel.OutboundCall
var err error
format := tchannel.Format(req.Encoding)
callOptions := tchannel.CallOptions{
Format: format,
ShardKey: req.ShardKey,
RoutingKey: req.RoutingKey,
RoutingDelegate: req.RoutingDelegate,
}
// If the hostport is given, we use the BeginCall on the channel
// instead of the subchannel.
call, err = peer.BeginCall(
// TODO(abg): Set TimeoutPerAttempt in the context's retry options if
// TTL is set.
// (kris): Consider instead moving TimeoutPerAttempt to an outer
// layer, just clamp the context on outbound call.
ctx,
req.Service,
req.Procedure,
&callOptions,
)
if err != nil {
return nil, err
}
reqHeaders := headerMap(req.Headers, headerCase)
// baggage headers are transport implementation details that are stripped out (and stored in the context). Users don't interact with it
tracingBaggage := tchannel.InjectOutboundSpan(call.Response(), nil)
if err := writeHeaders(format, reqHeaders, tracingBaggage, call.Arg2Writer); err != nil {
// TODO(abg): This will wrap IO errors while writing headers as encode
// errors. We should fix that.
return nil, errors.RequestHeadersEncodeError(req, err)
}
if err := writeBody(req.Body, call); err != nil {
return nil, err
}
res := call.Response()
headers, err := readHeaders(format, res.Arg2Reader)
if err != nil {
if err, ok := err.(tchannel.SystemError); ok {
return nil, fromSystemError(err)
}
// TODO(abg): This will wrap IO errors while reading headers as decode
// errors. We should fix that.
return nil, errors.ResponseHeadersDecodeError(req, err)
}
resBody, err := res.Arg3Reader()
if err != nil {
if err, ok := err.(tchannel.SystemError); ok {
return nil, fromSystemError(err)
}
return nil, err
}
respService, _ := headers.Get(ServiceHeaderKey) // validateServiceName handles empty strings
if err := validateServiceName(req.Service, respService); err != nil {
return nil, err
}
err = getResponseError(headers)
deleteReservedHeaders(headers)
resp := &transport.Response{
Headers: headers,
Body: resBody,
ApplicationError: res.ApplicationError(),
}
return resp, err
}
|
[
"func",
"callWithPeer",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"transport",
".",
"Request",
",",
"peer",
"*",
"tchannel",
".",
"Peer",
",",
"headerCase",
"headerCase",
")",
"(",
"*",
"transport",
".",
"Response",
",",
"error",
")",
"{",
"// NB(abg): Under the current API, the local service's name is required",
"// twice: once when constructing the TChannel and then again when",
"// constructing the RPC.",
"var",
"call",
"*",
"tchannel",
".",
"OutboundCall",
"\n",
"var",
"err",
"error",
"\n\n",
"format",
":=",
"tchannel",
".",
"Format",
"(",
"req",
".",
"Encoding",
")",
"\n",
"callOptions",
":=",
"tchannel",
".",
"CallOptions",
"{",
"Format",
":",
"format",
",",
"ShardKey",
":",
"req",
".",
"ShardKey",
",",
"RoutingKey",
":",
"req",
".",
"RoutingKey",
",",
"RoutingDelegate",
":",
"req",
".",
"RoutingDelegate",
",",
"}",
"\n\n",
"// If the hostport is given, we use the BeginCall on the channel",
"// instead of the subchannel.",
"call",
",",
"err",
"=",
"peer",
".",
"BeginCall",
"(",
"// TODO(abg): Set TimeoutPerAttempt in the context's retry options if",
"// TTL is set.",
"// (kris): Consider instead moving TimeoutPerAttempt to an outer",
"// layer, just clamp the context on outbound call.",
"ctx",
",",
"req",
".",
"Service",
",",
"req",
".",
"Procedure",
",",
"&",
"callOptions",
",",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"reqHeaders",
":=",
"headerMap",
"(",
"req",
".",
"Headers",
",",
"headerCase",
")",
"\n\n",
"// baggage headers are transport implementation details that are stripped out (and stored in the context). Users don't interact with it",
"tracingBaggage",
":=",
"tchannel",
".",
"InjectOutboundSpan",
"(",
"call",
".",
"Response",
"(",
")",
",",
"nil",
")",
"\n",
"if",
"err",
":=",
"writeHeaders",
"(",
"format",
",",
"reqHeaders",
",",
"tracingBaggage",
",",
"call",
".",
"Arg2Writer",
")",
";",
"err",
"!=",
"nil",
"{",
"// TODO(abg): This will wrap IO errors while writing headers as encode",
"// errors. We should fix that.",
"return",
"nil",
",",
"errors",
".",
"RequestHeadersEncodeError",
"(",
"req",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"writeBody",
"(",
"req",
".",
"Body",
",",
"call",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
":=",
"call",
".",
"Response",
"(",
")",
"\n",
"headers",
",",
"err",
":=",
"readHeaders",
"(",
"format",
",",
"res",
".",
"Arg2Reader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
",",
"ok",
":=",
"err",
".",
"(",
"tchannel",
".",
"SystemError",
")",
";",
"ok",
"{",
"return",
"nil",
",",
"fromSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"// TODO(abg): This will wrap IO errors while reading headers as decode",
"// errors. We should fix that.",
"return",
"nil",
",",
"errors",
".",
"ResponseHeadersDecodeError",
"(",
"req",
",",
"err",
")",
"\n",
"}",
"\n\n",
"resBody",
",",
"err",
":=",
"res",
".",
"Arg3Reader",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
",",
"ok",
":=",
"err",
".",
"(",
"tchannel",
".",
"SystemError",
")",
";",
"ok",
"{",
"return",
"nil",
",",
"fromSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"respService",
",",
"_",
":=",
"headers",
".",
"Get",
"(",
"ServiceHeaderKey",
")",
"// validateServiceName handles empty strings",
"\n",
"if",
"err",
":=",
"validateServiceName",
"(",
"req",
".",
"Service",
",",
"respService",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"getResponseError",
"(",
"headers",
")",
"\n",
"deleteReservedHeaders",
"(",
"headers",
")",
"\n\n",
"resp",
":=",
"&",
"transport",
".",
"Response",
"{",
"Headers",
":",
"headers",
",",
"Body",
":",
"resBody",
",",
"ApplicationError",
":",
"res",
".",
"ApplicationError",
"(",
")",
",",
"}",
"\n",
"return",
"resp",
",",
"err",
"\n",
"}"
] |
// callWithPeer sends a request with the chosen peer.
|
[
"callWithPeer",
"sends",
"a",
"request",
"with",
"the",
"chosen",
"peer",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/tchannel/outbound.go#L104-L182
|
10,549 |
yarpc/yarpc-go
|
transport/tchannel/outbound.go
|
Start
|
func (o *Outbound) Start() error {
return o.once.Start(o.chooser.Start)
}
|
go
|
func (o *Outbound) Start() error {
return o.once.Start(o.chooser.Start)
}
|
[
"func",
"(",
"o",
"*",
"Outbound",
")",
"Start",
"(",
")",
"error",
"{",
"return",
"o",
".",
"once",
".",
"Start",
"(",
"o",
".",
"chooser",
".",
"Start",
")",
"\n",
"}"
] |
// Start starts the TChannel outbound.
|
[
"Start",
"starts",
"the",
"TChannel",
"outbound",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/tchannel/outbound.go#L207-L209
|
10,550 |
yarpc/yarpc-go
|
transport/tchannel/outbound.go
|
Stop
|
func (o *Outbound) Stop() error {
return o.once.Stop(o.chooser.Stop)
}
|
go
|
func (o *Outbound) Stop() error {
return o.once.Stop(o.chooser.Stop)
}
|
[
"func",
"(",
"o",
"*",
"Outbound",
")",
"Stop",
"(",
")",
"error",
"{",
"return",
"o",
".",
"once",
".",
"Stop",
"(",
"o",
".",
"chooser",
".",
"Stop",
")",
"\n",
"}"
] |
// Stop stops the TChannel outbound.
|
[
"Stop",
"stops",
"the",
"TChannel",
"outbound",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/tchannel/outbound.go#L212-L214
|
10,551 |
yarpc/yarpc-go
|
pkg/procedure/procedure.go
|
ToName
|
func ToName(serviceName string, methodName string) string {
return fmt.Sprintf("%s::%s", serviceName, methodName)
}
|
go
|
func ToName(serviceName string, methodName string) string {
return fmt.Sprintf("%s::%s", serviceName, methodName)
}
|
[
"func",
"ToName",
"(",
"serviceName",
"string",
",",
"methodName",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"serviceName",
",",
"methodName",
")",
"\n",
"}"
] |
// ToName gets the procedure name we should use for a method
// with the given service name and method name.
|
[
"ToName",
"gets",
"the",
"procedure",
"name",
"we",
"should",
"use",
"for",
"a",
"method",
"with",
"the",
"given",
"service",
"name",
"and",
"method",
"name",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/pkg/procedure/procedure.go#L31-L33
|
10,552 |
yarpc/yarpc-go
|
pkg/procedure/procedure.go
|
FromName
|
func FromName(name string) (serviceName string, methodName string) {
parts := strings.SplitN(name, "::", 2)
if len(parts) == 1 {
return parts[0], ""
}
return parts[0], parts[1]
}
|
go
|
func FromName(name string) (serviceName string, methodName string) {
parts := strings.SplitN(name, "::", 2)
if len(parts) == 1 {
return parts[0], ""
}
return parts[0], parts[1]
}
|
[
"func",
"FromName",
"(",
"name",
"string",
")",
"(",
"serviceName",
"string",
",",
"methodName",
"string",
")",
"{",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"name",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"==",
"1",
"{",
"return",
"parts",
"[",
"0",
"]",
",",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"parts",
"[",
"0",
"]",
",",
"parts",
"[",
"1",
"]",
"\n",
"}"
] |
// FromName gets the service name and method name from a procdure name.
|
[
"FromName",
"gets",
"the",
"service",
"name",
"and",
"method",
"name",
"from",
"a",
"procdure",
"name",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/pkg/procedure/procedure.go#L36-L42
|
10,553 |
yarpc/yarpc-go
|
peer/pendingheap/list.go
|
New
|
func New(transport peer.Transport, opts ...ListOption) *List {
cfg := defaultListConfig
for _, o := range opts {
o(&cfg)
}
plOpts := []peerlist.ListOption{
peerlist.Capacity(cfg.capacity),
}
if !cfg.shuffle {
plOpts = append(plOpts, peerlist.NoShuffle())
}
nextRandFn := nextRand(cfg.seed)
if cfg.nextRand != nil {
// only true in tests
nextRandFn = cfg.nextRand
}
return &List{
List: peerlist.New(
"fewest-pending-requests",
transport,
&pendingHeap{
nextRand: nextRandFn,
},
plOpts...,
),
}
}
|
go
|
func New(transport peer.Transport, opts ...ListOption) *List {
cfg := defaultListConfig
for _, o := range opts {
o(&cfg)
}
plOpts := []peerlist.ListOption{
peerlist.Capacity(cfg.capacity),
}
if !cfg.shuffle {
plOpts = append(plOpts, peerlist.NoShuffle())
}
nextRandFn := nextRand(cfg.seed)
if cfg.nextRand != nil {
// only true in tests
nextRandFn = cfg.nextRand
}
return &List{
List: peerlist.New(
"fewest-pending-requests",
transport,
&pendingHeap{
nextRand: nextRandFn,
},
plOpts...,
),
}
}
|
[
"func",
"New",
"(",
"transport",
"peer",
".",
"Transport",
",",
"opts",
"...",
"ListOption",
")",
"*",
"List",
"{",
"cfg",
":=",
"defaultListConfig",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"opts",
"{",
"o",
"(",
"&",
"cfg",
")",
"\n",
"}",
"\n\n",
"plOpts",
":=",
"[",
"]",
"peerlist",
".",
"ListOption",
"{",
"peerlist",
".",
"Capacity",
"(",
"cfg",
".",
"capacity",
")",
",",
"}",
"\n",
"if",
"!",
"cfg",
".",
"shuffle",
"{",
"plOpts",
"=",
"append",
"(",
"plOpts",
",",
"peerlist",
".",
"NoShuffle",
"(",
")",
")",
"\n",
"}",
"\n\n",
"nextRandFn",
":=",
"nextRand",
"(",
"cfg",
".",
"seed",
")",
"\n",
"if",
"cfg",
".",
"nextRand",
"!=",
"nil",
"{",
"// only true in tests",
"nextRandFn",
"=",
"cfg",
".",
"nextRand",
"\n",
"}",
"\n\n",
"return",
"&",
"List",
"{",
"List",
":",
"peerlist",
".",
"New",
"(",
"\"",
"\"",
",",
"transport",
",",
"&",
"pendingHeap",
"{",
"nextRand",
":",
"nextRandFn",
",",
"}",
",",
"plOpts",
"...",
",",
")",
",",
"}",
"\n",
"}"
] |
// New creates a new pending heap.
|
[
"New",
"creates",
"a",
"new",
"pending",
"heap",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/pendingheap/list.go#L67-L96
|
10,554 |
yarpc/yarpc-go
|
peer/pendingheap/list.go
|
nextRand
|
func nextRand(seed int64) func(int) int {
r := rand.New(rand.NewSource(seed))
return func(numPeers int) int {
if numPeers == 0 {
return 0
}
return r.Intn(numPeers)
}
}
|
go
|
func nextRand(seed int64) func(int) int {
r := rand.New(rand.NewSource(seed))
return func(numPeers int) int {
if numPeers == 0 {
return 0
}
return r.Intn(numPeers)
}
}
|
[
"func",
"nextRand",
"(",
"seed",
"int64",
")",
"func",
"(",
"int",
")",
"int",
"{",
"r",
":=",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"seed",
")",
")",
"\n\n",
"return",
"func",
"(",
"numPeers",
"int",
")",
"int",
"{",
"if",
"numPeers",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"r",
".",
"Intn",
"(",
"numPeers",
")",
"\n",
"}",
"\n",
"}"
] |
// nextRand is a convenience function for creating a new rand.Rand from a given
// seed.
|
[
"nextRand",
"is",
"a",
"convenience",
"function",
"for",
"creating",
"a",
"new",
"rand",
".",
"Rand",
"from",
"a",
"given",
"seed",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/pendingheap/list.go#L105-L114
|
10,555 |
yarpc/yarpc-go
|
internal/examples/thrift-keyvalue/keyvalue/kv/types.go
|
String
|
func (v *ResourceDoesNotExist) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
fields[i] = fmt.Sprintf("Key: %v", v.Key)
i++
if v.Message != nil {
fields[i] = fmt.Sprintf("Message: %v", *(v.Message))
i++
}
return fmt.Sprintf("ResourceDoesNotExist{%v}", strings.Join(fields[:i], ", "))
}
|
go
|
func (v *ResourceDoesNotExist) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
fields[i] = fmt.Sprintf("Key: %v", v.Key)
i++
if v.Message != nil {
fields[i] = fmt.Sprintf("Message: %v", *(v.Message))
i++
}
return fmt.Sprintf("ResourceDoesNotExist{%v}", strings.Join(fields[:i], ", "))
}
|
[
"func",
"(",
"v",
"*",
"ResourceDoesNotExist",
")",
"String",
"(",
")",
"string",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"var",
"fields",
"[",
"2",
"]",
"string",
"\n",
"i",
":=",
"0",
"\n",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"Key",
")",
"\n",
"i",
"++",
"\n",
"if",
"v",
".",
"Message",
"!=",
"nil",
"{",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"(",
"v",
".",
"Message",
")",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"fields",
"[",
":",
"i",
"]",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// String returns a readable string representation of a ResourceDoesNotExist
// struct.
|
[
"String",
"returns",
"a",
"readable",
"string",
"representation",
"of",
"a",
"ResourceDoesNotExist",
"struct",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-keyvalue/keyvalue/kv/types.go#L134-L149
|
10,556 |
yarpc/yarpc-go
|
internal/examples/thrift-keyvalue/keyvalue/kv/types.go
|
Equals
|
func (v *ResourceDoesNotExist) Equals(rhs *ResourceDoesNotExist) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !(v.Key == rhs.Key) {
return false
}
if !_String_EqualsPtr(v.Message, rhs.Message) {
return false
}
return true
}
|
go
|
func (v *ResourceDoesNotExist) Equals(rhs *ResourceDoesNotExist) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !(v.Key == rhs.Key) {
return false
}
if !_String_EqualsPtr(v.Message, rhs.Message) {
return false
}
return true
}
|
[
"func",
"(",
"v",
"*",
"ResourceDoesNotExist",
")",
"Equals",
"(",
"rhs",
"*",
"ResourceDoesNotExist",
")",
"bool",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"rhs",
"==",
"nil",
"\n",
"}",
"else",
"if",
"rhs",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"v",
".",
"Key",
"==",
"rhs",
".",
"Key",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"_String_EqualsPtr",
"(",
"v",
".",
"Message",
",",
"rhs",
".",
"Message",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Equals returns true if all the fields of this ResourceDoesNotExist match the
// provided ResourceDoesNotExist.
//
// This function performs a deep comparison.
|
[
"Equals",
"returns",
"true",
"if",
"all",
"the",
"fields",
"of",
"this",
"ResourceDoesNotExist",
"match",
"the",
"provided",
"ResourceDoesNotExist",
".",
"This",
"function",
"performs",
"a",
"deep",
"comparison",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-keyvalue/keyvalue/kv/types.go#L165-L179
|
10,557 |
yarpc/yarpc-go
|
internal/examples/thrift-keyvalue/keyvalue/kv/types.go
|
MarshalLogObject
|
func (v *ResourceDoesNotExist) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
enc.AddString("key", v.Key)
if v.Message != nil {
enc.AddString("message", *v.Message)
}
return err
}
|
go
|
func (v *ResourceDoesNotExist) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
enc.AddString("key", v.Key)
if v.Message != nil {
enc.AddString("message", *v.Message)
}
return err
}
|
[
"func",
"(",
"v",
"*",
"ResourceDoesNotExist",
")",
"MarshalLogObject",
"(",
"enc",
"zapcore",
".",
"ObjectEncoder",
")",
"(",
"err",
"error",
")",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"v",
".",
"Key",
")",
"\n",
"if",
"v",
".",
"Message",
"!=",
"nil",
"{",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"*",
"v",
".",
"Message",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of ResourceDoesNotExist.
|
[
"MarshalLogObject",
"implements",
"zapcore",
".",
"ObjectMarshaler",
"enabling",
"fast",
"logging",
"of",
"ResourceDoesNotExist",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/thrift-keyvalue/keyvalue/kv/types.go#L183-L192
|
10,558 |
yarpc/yarpc-go
|
internal/examples/protobuf/examplepb/example.pb.yarpc.go
|
NewKeyValueYARPCClient
|
func NewKeyValueYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) KeyValueYARPCClient {
return &_KeyValueYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.KeyValue",
ClientConfig: clientConfig,
Options: options,
},
)}
}
|
go
|
func NewKeyValueYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) KeyValueYARPCClient {
return &_KeyValueYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.KeyValue",
ClientConfig: clientConfig,
Options: options,
},
)}
}
|
[
"func",
"NewKeyValueYARPCClient",
"(",
"clientConfig",
"transport",
".",
"ClientConfig",
",",
"options",
"...",
"protobuf",
".",
"ClientOption",
")",
"KeyValueYARPCClient",
"{",
"return",
"&",
"_KeyValueYARPCCaller",
"{",
"protobuf",
".",
"NewStreamClient",
"(",
"protobuf",
".",
"ClientParams",
"{",
"ServiceName",
":",
"\"",
"\"",
",",
"ClientConfig",
":",
"clientConfig",
",",
"Options",
":",
"options",
",",
"}",
",",
")",
"}",
"\n",
"}"
] |
// NewKeyValueYARPCClient builds a new YARPC client for the KeyValue service.
|
[
"NewKeyValueYARPCClient",
"builds",
"a",
"new",
"YARPC",
"client",
"for",
"the",
"KeyValue",
"service",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/examplepb/example.pb.yarpc.go#L50-L58
|
10,559 |
yarpc/yarpc-go
|
internal/examples/protobuf/examplepb/example.pb.yarpc.go
|
BuildKeyValueYARPCProcedures
|
func BuildKeyValueYARPCProcedures(server KeyValueYARPCServer) []transport.Procedure {
handler := &_KeyValueYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.KeyValue",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{
{
MethodName: "GetValue",
Handler: protobuf.NewUnaryHandler(
protobuf.UnaryHandlerParams{
Handle: handler.GetValue,
NewRequest: newKeyValueServiceGetValueYARPCRequest,
},
),
},
{
MethodName: "SetValue",
Handler: protobuf.NewUnaryHandler(
protobuf.UnaryHandlerParams{
Handle: handler.SetValue,
NewRequest: newKeyValueServiceSetValueYARPCRequest,
},
),
},
},
OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{},
StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{},
},
)
}
|
go
|
func BuildKeyValueYARPCProcedures(server KeyValueYARPCServer) []transport.Procedure {
handler := &_KeyValueYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.KeyValue",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{
{
MethodName: "GetValue",
Handler: protobuf.NewUnaryHandler(
protobuf.UnaryHandlerParams{
Handle: handler.GetValue,
NewRequest: newKeyValueServiceGetValueYARPCRequest,
},
),
},
{
MethodName: "SetValue",
Handler: protobuf.NewUnaryHandler(
protobuf.UnaryHandlerParams{
Handle: handler.SetValue,
NewRequest: newKeyValueServiceSetValueYARPCRequest,
},
),
},
},
OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{},
StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{},
},
)
}
|
[
"func",
"BuildKeyValueYARPCProcedures",
"(",
"server",
"KeyValueYARPCServer",
")",
"[",
"]",
"transport",
".",
"Procedure",
"{",
"handler",
":=",
"&",
"_KeyValueYARPCHandler",
"{",
"server",
"}",
"\n",
"return",
"protobuf",
".",
"BuildProcedures",
"(",
"protobuf",
".",
"BuildProceduresParams",
"{",
"ServiceName",
":",
"\"",
"\"",
",",
"UnaryHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresUnaryHandlerParams",
"{",
"{",
"MethodName",
":",
"\"",
"\"",
",",
"Handler",
":",
"protobuf",
".",
"NewUnaryHandler",
"(",
"protobuf",
".",
"UnaryHandlerParams",
"{",
"Handle",
":",
"handler",
".",
"GetValue",
",",
"NewRequest",
":",
"newKeyValueServiceGetValueYARPCRequest",
",",
"}",
",",
")",
",",
"}",
",",
"{",
"MethodName",
":",
"\"",
"\"",
",",
"Handler",
":",
"protobuf",
".",
"NewUnaryHandler",
"(",
"protobuf",
".",
"UnaryHandlerParams",
"{",
"Handle",
":",
"handler",
".",
"SetValue",
",",
"NewRequest",
":",
"newKeyValueServiceSetValueYARPCRequest",
",",
"}",
",",
")",
",",
"}",
",",
"}",
",",
"OnewayHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresOnewayHandlerParams",
"{",
"}",
",",
"StreamHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresStreamHandlerParams",
"{",
"}",
",",
"}",
",",
")",
"\n",
"}"
] |
// BuildKeyValueYARPCProcedures prepares an implementation of the KeyValue service for YARPC registration.
|
[
"BuildKeyValueYARPCProcedures",
"prepares",
"an",
"implementation",
"of",
"the",
"KeyValue",
"service",
"for",
"YARPC",
"registration",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/examplepb/example.pb.yarpc.go#L67-L96
|
10,560 |
yarpc/yarpc-go
|
internal/examples/protobuf/examplepb/example.pb.yarpc.go
|
NewSinkYARPCClient
|
func NewSinkYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) SinkYARPCClient {
return &_SinkYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Sink",
ClientConfig: clientConfig,
Options: options,
},
)}
}
|
go
|
func NewSinkYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) SinkYARPCClient {
return &_SinkYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Sink",
ClientConfig: clientConfig,
Options: options,
},
)}
}
|
[
"func",
"NewSinkYARPCClient",
"(",
"clientConfig",
"transport",
".",
"ClientConfig",
",",
"options",
"...",
"protobuf",
".",
"ClientOption",
")",
"SinkYARPCClient",
"{",
"return",
"&",
"_SinkYARPCCaller",
"{",
"protobuf",
".",
"NewStreamClient",
"(",
"protobuf",
".",
"ClientParams",
"{",
"ServiceName",
":",
"\"",
"\"",
",",
"ClientConfig",
":",
"clientConfig",
",",
"Options",
":",
"options",
",",
"}",
",",
")",
"}",
"\n",
"}"
] |
// NewSinkYARPCClient builds a new YARPC client for the Sink service.
|
[
"NewSinkYARPCClient",
"builds",
"a",
"new",
"YARPC",
"client",
"for",
"the",
"Sink",
"service",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/examplepb/example.pb.yarpc.go#L271-L279
|
10,561 |
yarpc/yarpc-go
|
internal/examples/protobuf/examplepb/example.pb.yarpc.go
|
BuildSinkYARPCProcedures
|
func BuildSinkYARPCProcedures(server SinkYARPCServer) []transport.Procedure {
handler := &_SinkYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Sink",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{},
OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{
{
MethodName: "Fire",
Handler: protobuf.NewOnewayHandler(
protobuf.OnewayHandlerParams{
Handle: handler.Fire,
NewRequest: newSinkServiceFireYARPCRequest,
},
),
},
},
StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{},
},
)
}
|
go
|
func BuildSinkYARPCProcedures(server SinkYARPCServer) []transport.Procedure {
handler := &_SinkYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Sink",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{},
OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{
{
MethodName: "Fire",
Handler: protobuf.NewOnewayHandler(
protobuf.OnewayHandlerParams{
Handle: handler.Fire,
NewRequest: newSinkServiceFireYARPCRequest,
},
),
},
},
StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{},
},
)
}
|
[
"func",
"BuildSinkYARPCProcedures",
"(",
"server",
"SinkYARPCServer",
")",
"[",
"]",
"transport",
".",
"Procedure",
"{",
"handler",
":=",
"&",
"_SinkYARPCHandler",
"{",
"server",
"}",
"\n",
"return",
"protobuf",
".",
"BuildProcedures",
"(",
"protobuf",
".",
"BuildProceduresParams",
"{",
"ServiceName",
":",
"\"",
"\"",
",",
"UnaryHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresUnaryHandlerParams",
"{",
"}",
",",
"OnewayHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresOnewayHandlerParams",
"{",
"{",
"MethodName",
":",
"\"",
"\"",
",",
"Handler",
":",
"protobuf",
".",
"NewOnewayHandler",
"(",
"protobuf",
".",
"OnewayHandlerParams",
"{",
"Handle",
":",
"handler",
".",
"Fire",
",",
"NewRequest",
":",
"newSinkServiceFireYARPCRequest",
",",
"}",
",",
")",
",",
"}",
",",
"}",
",",
"StreamHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresStreamHandlerParams",
"{",
"}",
",",
"}",
",",
")",
"\n",
"}"
] |
// BuildSinkYARPCProcedures prepares an implementation of the Sink service for YARPC registration.
|
[
"BuildSinkYARPCProcedures",
"prepares",
"an",
"implementation",
"of",
"the",
"Sink",
"service",
"for",
"YARPC",
"registration",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/examplepb/example.pb.yarpc.go#L287-L307
|
10,562 |
yarpc/yarpc-go
|
internal/examples/protobuf/examplepb/example.pb.yarpc.go
|
NewFooYARPCClient
|
func NewFooYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) FooYARPCClient {
return &_FooYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Foo",
ClientConfig: clientConfig,
Options: options,
},
)}
}
|
go
|
func NewFooYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) FooYARPCClient {
return &_FooYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Foo",
ClientConfig: clientConfig,
Options: options,
},
)}
}
|
[
"func",
"NewFooYARPCClient",
"(",
"clientConfig",
"transport",
".",
"ClientConfig",
",",
"options",
"...",
"protobuf",
".",
"ClientOption",
")",
"FooYARPCClient",
"{",
"return",
"&",
"_FooYARPCCaller",
"{",
"protobuf",
".",
"NewStreamClient",
"(",
"protobuf",
".",
"ClientParams",
"{",
"ServiceName",
":",
"\"",
"\"",
",",
"ClientConfig",
":",
"clientConfig",
",",
"Options",
":",
"options",
",",
"}",
",",
")",
"}",
"\n",
"}"
] |
// NewFooYARPCClient builds a new YARPC client for the Foo service.
|
[
"NewFooYARPCClient",
"builds",
"a",
"new",
"YARPC",
"client",
"for",
"the",
"Foo",
"service",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/examplepb/example.pb.yarpc.go#L456-L464
|
10,563 |
yarpc/yarpc-go
|
internal/examples/protobuf/examplepb/example.pb.yarpc.go
|
BuildFooYARPCProcedures
|
func BuildFooYARPCProcedures(server FooYARPCServer) []transport.Procedure {
handler := &_FooYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Foo",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{},
OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{},
StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{
{
MethodName: "EchoBoth",
Handler: protobuf.NewStreamHandler(
protobuf.StreamHandlerParams{
Handle: handler.EchoBoth,
},
),
},
{
MethodName: "EchoIn",
Handler: protobuf.NewStreamHandler(
protobuf.StreamHandlerParams{
Handle: handler.EchoIn,
},
),
},
{
MethodName: "EchoOut",
Handler: protobuf.NewStreamHandler(
protobuf.StreamHandlerParams{
Handle: handler.EchoOut,
},
),
},
},
},
)
}
|
go
|
func BuildFooYARPCProcedures(server FooYARPCServer) []transport.Procedure {
handler := &_FooYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Foo",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{},
OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{},
StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{
{
MethodName: "EchoBoth",
Handler: protobuf.NewStreamHandler(
protobuf.StreamHandlerParams{
Handle: handler.EchoBoth,
},
),
},
{
MethodName: "EchoIn",
Handler: protobuf.NewStreamHandler(
protobuf.StreamHandlerParams{
Handle: handler.EchoIn,
},
),
},
{
MethodName: "EchoOut",
Handler: protobuf.NewStreamHandler(
protobuf.StreamHandlerParams{
Handle: handler.EchoOut,
},
),
},
},
},
)
}
|
[
"func",
"BuildFooYARPCProcedures",
"(",
"server",
"FooYARPCServer",
")",
"[",
"]",
"transport",
".",
"Procedure",
"{",
"handler",
":=",
"&",
"_FooYARPCHandler",
"{",
"server",
"}",
"\n",
"return",
"protobuf",
".",
"BuildProcedures",
"(",
"protobuf",
".",
"BuildProceduresParams",
"{",
"ServiceName",
":",
"\"",
"\"",
",",
"UnaryHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresUnaryHandlerParams",
"{",
"}",
",",
"OnewayHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresOnewayHandlerParams",
"{",
"}",
",",
"StreamHandlerParams",
":",
"[",
"]",
"protobuf",
".",
"BuildProceduresStreamHandlerParams",
"{",
"{",
"MethodName",
":",
"\"",
"\"",
",",
"Handler",
":",
"protobuf",
".",
"NewStreamHandler",
"(",
"protobuf",
".",
"StreamHandlerParams",
"{",
"Handle",
":",
"handler",
".",
"EchoBoth",
",",
"}",
",",
")",
",",
"}",
",",
"{",
"MethodName",
":",
"\"",
"\"",
",",
"Handler",
":",
"protobuf",
".",
"NewStreamHandler",
"(",
"protobuf",
".",
"StreamHandlerParams",
"{",
"Handle",
":",
"handler",
".",
"EchoIn",
",",
"}",
",",
")",
",",
"}",
",",
"{",
"MethodName",
":",
"\"",
"\"",
",",
"Handler",
":",
"protobuf",
".",
"NewStreamHandler",
"(",
"protobuf",
".",
"StreamHandlerParams",
"{",
"Handle",
":",
"handler",
".",
"EchoOut",
",",
"}",
",",
")",
",",
"}",
",",
"}",
",",
"}",
",",
")",
"\n",
"}"
] |
// BuildFooYARPCProcedures prepares an implementation of the Foo service for YARPC registration.
|
[
"BuildFooYARPCProcedures",
"prepares",
"an",
"implementation",
"of",
"the",
"Foo",
"service",
"for",
"YARPC",
"registration",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/examples/protobuf/examplepb/example.pb.yarpc.go#L493-L530
|
10,564 |
yarpc/yarpc-go
|
peer/randpeer/list.go
|
Seed
|
func Seed(seed int64) ListOption {
return listOptionFunc(func(options *listOptions) {
options.source = rand.NewSource(seed)
})
}
|
go
|
func Seed(seed int64) ListOption {
return listOptionFunc(func(options *listOptions) {
options.source = rand.NewSource(seed)
})
}
|
[
"func",
"Seed",
"(",
"seed",
"int64",
")",
"ListOption",
"{",
"return",
"listOptionFunc",
"(",
"func",
"(",
"options",
"*",
"listOptions",
")",
"{",
"options",
".",
"source",
"=",
"rand",
".",
"NewSource",
"(",
"seed",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// Seed specifies the seed for generating random choices.
|
[
"Seed",
"specifies",
"the",
"seed",
"for",
"generating",
"random",
"choices",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/randpeer/list.go#L60-L64
|
10,565 |
yarpc/yarpc-go
|
peer/randpeer/list.go
|
Source
|
func Source(source rand.Source) ListOption {
return listOptionFunc(func(options *listOptions) {
options.source = source
})
}
|
go
|
func Source(source rand.Source) ListOption {
return listOptionFunc(func(options *listOptions) {
options.source = source
})
}
|
[
"func",
"Source",
"(",
"source",
"rand",
".",
"Source",
")",
"ListOption",
"{",
"return",
"listOptionFunc",
"(",
"func",
"(",
"options",
"*",
"listOptions",
")",
"{",
"options",
".",
"source",
"=",
"source",
"\n",
"}",
")",
"\n",
"}"
] |
// Source is a source of randomness for the peer list.
|
[
"Source",
"is",
"a",
"source",
"of",
"randomness",
"for",
"the",
"peer",
"list",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/randpeer/list.go#L67-L71
|
10,566 |
yarpc/yarpc-go
|
peer/randpeer/list.go
|
New
|
func New(transport peer.Transport, opts ...ListOption) *List {
options := defaultListOptions
for _, opt := range opts {
opt.apply(&options)
}
if options.source == nil {
options.source = rand.NewSource(time.Now().UnixNano())
}
plOpts := []peerlist.ListOption{
peerlist.Capacity(options.capacity),
peerlist.NoShuffle(),
}
return &List{
List: peerlist.New(
"random",
transport,
newRandomList(options.capacity, options.source),
plOpts...,
),
}
}
|
go
|
func New(transport peer.Transport, opts ...ListOption) *List {
options := defaultListOptions
for _, opt := range opts {
opt.apply(&options)
}
if options.source == nil {
options.source = rand.NewSource(time.Now().UnixNano())
}
plOpts := []peerlist.ListOption{
peerlist.Capacity(options.capacity),
peerlist.NoShuffle(),
}
return &List{
List: peerlist.New(
"random",
transport,
newRandomList(options.capacity, options.source),
plOpts...,
),
}
}
|
[
"func",
"New",
"(",
"transport",
"peer",
".",
"Transport",
",",
"opts",
"...",
"ListOption",
")",
"*",
"List",
"{",
"options",
":=",
"defaultListOptions",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
".",
"apply",
"(",
"&",
"options",
")",
"\n",
"}",
"\n\n",
"if",
"options",
".",
"source",
"==",
"nil",
"{",
"options",
".",
"source",
"=",
"rand",
".",
"NewSource",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
"\n",
"}",
"\n\n",
"plOpts",
":=",
"[",
"]",
"peerlist",
".",
"ListOption",
"{",
"peerlist",
".",
"Capacity",
"(",
"options",
".",
"capacity",
")",
",",
"peerlist",
".",
"NoShuffle",
"(",
")",
",",
"}",
"\n\n",
"return",
"&",
"List",
"{",
"List",
":",
"peerlist",
".",
"New",
"(",
"\"",
"\"",
",",
"transport",
",",
"newRandomList",
"(",
"options",
".",
"capacity",
",",
"options",
".",
"source",
")",
",",
"plOpts",
"...",
",",
")",
",",
"}",
"\n",
"}"
] |
// New creates a new random peer list.
|
[
"New",
"creates",
"a",
"new",
"random",
"peer",
"list",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/randpeer/list.go#L74-L97
|
10,567 |
yarpc/yarpc-go
|
internal/errorsync/err.go
|
Submit
|
func (ew *ErrorWaiter) Submit(f func() error) {
ew.wait.Add(1)
go func() {
defer ew.wait.Done()
if err := f(); err != nil {
ew.lock.Lock()
ew.errors = append(ew.errors, err)
ew.lock.Unlock()
}
}()
}
|
go
|
func (ew *ErrorWaiter) Submit(f func() error) {
ew.wait.Add(1)
go func() {
defer ew.wait.Done()
if err := f(); err != nil {
ew.lock.Lock()
ew.errors = append(ew.errors, err)
ew.lock.Unlock()
}
}()
}
|
[
"func",
"(",
"ew",
"*",
"ErrorWaiter",
")",
"Submit",
"(",
"f",
"func",
"(",
")",
"error",
")",
"{",
"ew",
".",
"wait",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"ew",
".",
"wait",
".",
"Done",
"(",
")",
"\n",
"if",
"err",
":=",
"f",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"ew",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"ew",
".",
"errors",
"=",
"append",
"(",
"ew",
".",
"errors",
",",
"err",
")",
"\n",
"ew",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}"
] |
// Submit submits a task for execution on the ErrorWaiter.
//
// The function returns immediately.
|
[
"Submit",
"submits",
"a",
"task",
"for",
"execution",
"on",
"the",
"ErrorWaiter",
".",
"The",
"function",
"returns",
"immediately",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/errorsync/err.go#L36-L46
|
10,568 |
yarpc/yarpc-go
|
encoding/raw/register.go
|
Procedure
|
func Procedure(name string, handler UnaryHandler) []transport.Procedure {
return []transport.Procedure{
{
Name: name,
HandlerSpec: transport.NewUnaryHandlerSpec(rawUnaryHandler{handler}),
},
}
}
|
go
|
func Procedure(name string, handler UnaryHandler) []transport.Procedure {
return []transport.Procedure{
{
Name: name,
HandlerSpec: transport.NewUnaryHandlerSpec(rawUnaryHandler{handler}),
},
}
}
|
[
"func",
"Procedure",
"(",
"name",
"string",
",",
"handler",
"UnaryHandler",
")",
"[",
"]",
"transport",
".",
"Procedure",
"{",
"return",
"[",
"]",
"transport",
".",
"Procedure",
"{",
"{",
"Name",
":",
"name",
",",
"HandlerSpec",
":",
"transport",
".",
"NewUnaryHandlerSpec",
"(",
"rawUnaryHandler",
"{",
"handler",
"}",
")",
",",
"}",
",",
"}",
"\n",
"}"
] |
// Procedure builds a Procedure from the given raw handler.
|
[
"Procedure",
"builds",
"a",
"Procedure",
"from",
"the",
"given",
"raw",
"handler",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/raw/register.go#L43-L50
|
10,569 |
yarpc/yarpc-go
|
encoding/raw/register.go
|
OnewayProcedure
|
func OnewayProcedure(name string, handler OnewayHandler) []transport.Procedure {
return []transport.Procedure{
{
Name: name,
HandlerSpec: transport.NewOnewayHandlerSpec(rawOnewayHandler{handler}),
},
}
}
|
go
|
func OnewayProcedure(name string, handler OnewayHandler) []transport.Procedure {
return []transport.Procedure{
{
Name: name,
HandlerSpec: transport.NewOnewayHandlerSpec(rawOnewayHandler{handler}),
},
}
}
|
[
"func",
"OnewayProcedure",
"(",
"name",
"string",
",",
"handler",
"OnewayHandler",
")",
"[",
"]",
"transport",
".",
"Procedure",
"{",
"return",
"[",
"]",
"transport",
".",
"Procedure",
"{",
"{",
"Name",
":",
"name",
",",
"HandlerSpec",
":",
"transport",
".",
"NewOnewayHandlerSpec",
"(",
"rawOnewayHandler",
"{",
"handler",
"}",
")",
",",
"}",
",",
"}",
"\n",
"}"
] |
// OnewayProcedure builds a Procedure from the given raw handler
|
[
"OnewayProcedure",
"builds",
"a",
"Procedure",
"from",
"the",
"given",
"raw",
"handler"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/raw/register.go#L56-L63
|
10,570 |
yarpc/yarpc-go
|
internal/crossdock/server/yarpc/sleep.go
|
SleepRaw
|
func SleepRaw(ctx context.Context, body []byte) ([]byte, error) {
time.Sleep(1 * time.Second)
return nil, nil
}
|
go
|
func SleepRaw(ctx context.Context, body []byte) ([]byte, error) {
time.Sleep(1 * time.Second)
return nil, nil
}
|
[
"func",
"SleepRaw",
"(",
"ctx",
"context",
".",
"Context",
",",
"body",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"time",
".",
"Sleep",
"(",
"1",
"*",
"time",
".",
"Second",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] |
// SleepRaw responds to raw requests over any transport by sleeping for one
// second.
|
[
"SleepRaw",
"responds",
"to",
"raw",
"requests",
"over",
"any",
"transport",
"by",
"sleeping",
"for",
"one",
"second",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/server/yarpc/sleep.go#L31-L34
|
10,571 |
yarpc/yarpc-go
|
internal/crossdock/server/yarpc/sleep.go
|
WaitForTimeoutRaw
|
func WaitForTimeoutRaw(ctx context.Context, body []byte) ([]byte, error) {
if _, ok := ctx.Deadline(); !ok {
return nil, fmt.Errorf("no deadline set in context")
}
<-ctx.Done()
return nil, ctx.Err()
}
|
go
|
func WaitForTimeoutRaw(ctx context.Context, body []byte) ([]byte, error) {
if _, ok := ctx.Deadline(); !ok {
return nil, fmt.Errorf("no deadline set in context")
}
<-ctx.Done()
return nil, ctx.Err()
}
|
[
"func",
"WaitForTimeoutRaw",
"(",
"ctx",
"context",
".",
"Context",
",",
"body",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"ctx",
".",
"Deadline",
"(",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"<-",
"ctx",
".",
"Done",
"(",
")",
"\n",
"return",
"nil",
",",
"ctx",
".",
"Err",
"(",
")",
"\n",
"}"
] |
// WaitForTimeoutRaw waits after the context deadline then returns the context
// error. yarpc should interpret this as an handler timeout, which in turns
// should be forwarded to the yarpc client as a remote handler timeout.
|
[
"WaitForTimeoutRaw",
"waits",
"after",
"the",
"context",
"deadline",
"then",
"returns",
"the",
"context",
"error",
".",
"yarpc",
"should",
"interpret",
"this",
"as",
"an",
"handler",
"timeout",
"which",
"in",
"turns",
"should",
"be",
"forwarded",
"to",
"the",
"yarpc",
"client",
"as",
"a",
"remote",
"handler",
"timeout",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/server/yarpc/sleep.go#L46-L52
|
10,572 |
yarpc/yarpc-go
|
pkg/errors/client.go
|
RequestBodyEncodeError
|
func RequestBodyEncodeError(req *transport.Request, err error) error {
return newClientEncodingError(req, false /*isResponse*/, false /*isHeader*/, err)
}
|
go
|
func RequestBodyEncodeError(req *transport.Request, err error) error {
return newClientEncodingError(req, false /*isResponse*/, false /*isHeader*/, err)
}
|
[
"func",
"RequestBodyEncodeError",
"(",
"req",
"*",
"transport",
".",
"Request",
",",
"err",
"error",
")",
"error",
"{",
"return",
"newClientEncodingError",
"(",
"req",
",",
"false",
"/*isResponse*/",
",",
"false",
"/*isHeader*/",
",",
"err",
")",
"\n",
"}"
] |
// RequestBodyEncodeError builds a YARPC error with code
// yarpcerrors.CodeInvalidArgument that represents a failure to encode
// the request body.
|
[
"RequestBodyEncodeError",
"builds",
"a",
"YARPC",
"error",
"with",
"code",
"yarpcerrors",
".",
"CodeInvalidArgument",
"that",
"represents",
"a",
"failure",
"to",
"encode",
"the",
"request",
"body",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/pkg/errors/client.go#L34-L36
|
10,573 |
yarpc/yarpc-go
|
pkg/errors/client.go
|
RequestHeadersEncodeError
|
func RequestHeadersEncodeError(req *transport.Request, err error) error {
return newClientEncodingError(req, false /*isResponse*/, true /*isHeader*/, err)
}
|
go
|
func RequestHeadersEncodeError(req *transport.Request, err error) error {
return newClientEncodingError(req, false /*isResponse*/, true /*isHeader*/, err)
}
|
[
"func",
"RequestHeadersEncodeError",
"(",
"req",
"*",
"transport",
".",
"Request",
",",
"err",
"error",
")",
"error",
"{",
"return",
"newClientEncodingError",
"(",
"req",
",",
"false",
"/*isResponse*/",
",",
"true",
"/*isHeader*/",
",",
"err",
")",
"\n",
"}"
] |
// RequestHeadersEncodeError builds a YARPC error with code
// yarpcerrors.CodeInvalidArgument that represents a failure to
// encode the request headers.
|
[
"RequestHeadersEncodeError",
"builds",
"a",
"YARPC",
"error",
"with",
"code",
"yarpcerrors",
".",
"CodeInvalidArgument",
"that",
"represents",
"a",
"failure",
"to",
"encode",
"the",
"request",
"headers",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/pkg/errors/client.go#L48-L50
|
10,574 |
yarpc/yarpc-go
|
pkg/errors/client.go
|
ResponseHeadersDecodeError
|
func ResponseHeadersDecodeError(req *transport.Request, err error) error {
return newClientEncodingError(req, true /*isResponse*/, true /*isHeader*/, err)
}
|
go
|
func ResponseHeadersDecodeError(req *transport.Request, err error) error {
return newClientEncodingError(req, true /*isResponse*/, true /*isHeader*/, err)
}
|
[
"func",
"ResponseHeadersDecodeError",
"(",
"req",
"*",
"transport",
".",
"Request",
",",
"err",
"error",
")",
"error",
"{",
"return",
"newClientEncodingError",
"(",
"req",
",",
"true",
"/*isResponse*/",
",",
"true",
"/*isHeader*/",
",",
"err",
")",
"\n",
"}"
] |
// ResponseHeadersDecodeError builds a YARPC error with code
// yarpcerrors.CodeInvalidArgument that represents a failure to
// decode the response headers.
|
[
"ResponseHeadersDecodeError",
"builds",
"a",
"YARPC",
"error",
"with",
"code",
"yarpcerrors",
".",
"CodeInvalidArgument",
"that",
"represents",
"a",
"failure",
"to",
"decode",
"the",
"response",
"headers",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/pkg/errors/client.go#L55-L57
|
10,575 |
yarpc/yarpc-go
|
encoding/protobuf/stream.go
|
readFromStream
|
func readFromStream(
ctx context.Context,
stream transport.Stream,
newMessage func() proto.Message,
) (proto.Message, error) {
streamMsg, err := stream.ReceiveMessage(ctx)
if err != nil {
return nil, err
}
message := newMessage()
if err := unmarshal(stream.Request().Meta.Encoding, streamMsg.Body, message); err != nil {
streamMsg.Body.Close()
return nil, err
}
if streamMsg.Body != nil {
streamMsg.Body.Close()
}
return message, nil
}
|
go
|
func readFromStream(
ctx context.Context,
stream transport.Stream,
newMessage func() proto.Message,
) (proto.Message, error) {
streamMsg, err := stream.ReceiveMessage(ctx)
if err != nil {
return nil, err
}
message := newMessage()
if err := unmarshal(stream.Request().Meta.Encoding, streamMsg.Body, message); err != nil {
streamMsg.Body.Close()
return nil, err
}
if streamMsg.Body != nil {
streamMsg.Body.Close()
}
return message, nil
}
|
[
"func",
"readFromStream",
"(",
"ctx",
"context",
".",
"Context",
",",
"stream",
"transport",
".",
"Stream",
",",
"newMessage",
"func",
"(",
")",
"proto",
".",
"Message",
",",
")",
"(",
"proto",
".",
"Message",
",",
"error",
")",
"{",
"streamMsg",
",",
"err",
":=",
"stream",
".",
"ReceiveMessage",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"message",
":=",
"newMessage",
"(",
")",
"\n",
"if",
"err",
":=",
"unmarshal",
"(",
"stream",
".",
"Request",
"(",
")",
".",
"Meta",
".",
"Encoding",
",",
"streamMsg",
".",
"Body",
",",
"message",
")",
";",
"err",
"!=",
"nil",
"{",
"streamMsg",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"streamMsg",
".",
"Body",
"!=",
"nil",
"{",
"streamMsg",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"message",
",",
"nil",
"\n",
"}"
] |
// readFromStream reads a proto.Message from a stream.
|
[
"readFromStream",
"reads",
"a",
"proto",
".",
"Message",
"from",
"a",
"stream",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/stream.go#L33-L51
|
10,576 |
yarpc/yarpc-go
|
encoding/protobuf/stream.go
|
writeToStream
|
func writeToStream(ctx context.Context, stream transport.Stream, message proto.Message) error {
messageData, cleanup, err := marshal(stream.Request().Meta.Encoding, message)
if err != nil {
return err
}
return stream.SendMessage(
ctx,
&transport.StreamMessage{
Body: readCloser{Reader: bytes.NewReader(messageData), closer: cleanup},
},
)
}
|
go
|
func writeToStream(ctx context.Context, stream transport.Stream, message proto.Message) error {
messageData, cleanup, err := marshal(stream.Request().Meta.Encoding, message)
if err != nil {
return err
}
return stream.SendMessage(
ctx,
&transport.StreamMessage{
Body: readCloser{Reader: bytes.NewReader(messageData), closer: cleanup},
},
)
}
|
[
"func",
"writeToStream",
"(",
"ctx",
"context",
".",
"Context",
",",
"stream",
"transport",
".",
"Stream",
",",
"message",
"proto",
".",
"Message",
")",
"error",
"{",
"messageData",
",",
"cleanup",
",",
"err",
":=",
"marshal",
"(",
"stream",
".",
"Request",
"(",
")",
".",
"Meta",
".",
"Encoding",
",",
"message",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"stream",
".",
"SendMessage",
"(",
"ctx",
",",
"&",
"transport",
".",
"StreamMessage",
"{",
"Body",
":",
"readCloser",
"{",
"Reader",
":",
"bytes",
".",
"NewReader",
"(",
"messageData",
")",
",",
"closer",
":",
"cleanup",
"}",
",",
"}",
",",
")",
"\n",
"}"
] |
// writeToStream writes a proto.Message to a stream.
|
[
"writeToStream",
"writes",
"a",
"proto",
".",
"Message",
"to",
"a",
"stream",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/encoding/protobuf/stream.go#L54-L65
|
10,577 |
yarpc/yarpc-go
|
x/debug/debug.go
|
NewHandler
|
func NewHandler(dispatcher *yarpc.Dispatcher, opts ...Option) http.HandlerFunc {
return newHandler(dispatcher, opts...).handle
}
|
go
|
func NewHandler(dispatcher *yarpc.Dispatcher, opts ...Option) http.HandlerFunc {
return newHandler(dispatcher, opts...).handle
}
|
[
"func",
"NewHandler",
"(",
"dispatcher",
"*",
"yarpc",
".",
"Dispatcher",
",",
"opts",
"...",
"Option",
")",
"http",
".",
"HandlerFunc",
"{",
"return",
"newHandler",
"(",
"dispatcher",
",",
"opts",
"...",
")",
".",
"handle",
"\n",
"}"
] |
// NewHandler returns a http.HandlerFunc to expose dispatcher status and package versions.
|
[
"NewHandler",
"returns",
"a",
"http",
".",
"HandlerFunc",
"to",
"expose",
"dispatcher",
"status",
"and",
"package",
"versions",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/x/debug/debug.go#L180-L182
|
10,578 |
yarpc/yarpc-go
|
peer/x/peerheap/heap.go
|
Swap
|
func (ph *peerHeap) Swap(i, j int) {
p1 := ph.peers[i]
p2 := ph.peers[j]
ph.peers[i], ph.peers[j] = ph.peers[j], ph.peers[i]
p1.idx = j
p2.idx = i
}
|
go
|
func (ph *peerHeap) Swap(i, j int) {
p1 := ph.peers[i]
p2 := ph.peers[j]
ph.peers[i], ph.peers[j] = ph.peers[j], ph.peers[i]
p1.idx = j
p2.idx = i
}
|
[
"func",
"(",
"ph",
"*",
"peerHeap",
")",
"Swap",
"(",
"i",
",",
"j",
"int",
")",
"{",
"p1",
":=",
"ph",
".",
"peers",
"[",
"i",
"]",
"\n",
"p2",
":=",
"ph",
".",
"peers",
"[",
"j",
"]",
"\n\n",
"ph",
".",
"peers",
"[",
"i",
"]",
",",
"ph",
".",
"peers",
"[",
"j",
"]",
"=",
"ph",
".",
"peers",
"[",
"j",
"]",
",",
"ph",
".",
"peers",
"[",
"i",
"]",
"\n",
"p1",
".",
"idx",
"=",
"j",
"\n",
"p2",
".",
"idx",
"=",
"i",
"\n",
"}"
] |
// Swap implements the heap.Interface. Do NOT use this method directly.
|
[
"Swap",
"implements",
"the",
"heap",
".",
"Interface",
".",
"Do",
"NOT",
"use",
"this",
"method",
"directly",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/x/peerheap/heap.go#L53-L60
|
10,579 |
yarpc/yarpc-go
|
peer/x/peerheap/heap.go
|
Push
|
func (ph *peerHeap) Push(x interface{}) {
ps := x.(*peerScore)
ps.idx = len(ph.peers)
ph.peers = append(ph.peers, ps)
}
|
go
|
func (ph *peerHeap) Push(x interface{}) {
ps := x.(*peerScore)
ps.idx = len(ph.peers)
ph.peers = append(ph.peers, ps)
}
|
[
"func",
"(",
"ph",
"*",
"peerHeap",
")",
"Push",
"(",
"x",
"interface",
"{",
"}",
")",
"{",
"ps",
":=",
"x",
".",
"(",
"*",
"peerScore",
")",
"\n",
"ps",
".",
"idx",
"=",
"len",
"(",
"ph",
".",
"peers",
")",
"\n",
"ph",
".",
"peers",
"=",
"append",
"(",
"ph",
".",
"peers",
",",
"ps",
")",
"\n",
"}"
] |
// Push implements the heap.Interface. Do NOT use this method directly.
// Use pushPeer instead.
|
[
"Push",
"implements",
"the",
"heap",
".",
"Interface",
".",
"Do",
"NOT",
"use",
"this",
"method",
"directly",
".",
"Use",
"pushPeer",
"instead",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/x/peerheap/heap.go#L64-L68
|
10,580 |
yarpc/yarpc-go
|
peer/x/peerheap/heap.go
|
Pop
|
func (ph *peerHeap) Pop() interface{} {
lastIdx := len(ph.peers) - 1
last := ph.peers[lastIdx]
ph.peers = ph.peers[:lastIdx]
return last
}
|
go
|
func (ph *peerHeap) Pop() interface{} {
lastIdx := len(ph.peers) - 1
last := ph.peers[lastIdx]
ph.peers = ph.peers[:lastIdx]
return last
}
|
[
"func",
"(",
"ph",
"*",
"peerHeap",
")",
"Pop",
"(",
")",
"interface",
"{",
"}",
"{",
"lastIdx",
":=",
"len",
"(",
"ph",
".",
"peers",
")",
"-",
"1",
"\n",
"last",
":=",
"ph",
".",
"peers",
"[",
"lastIdx",
"]",
"\n",
"ph",
".",
"peers",
"=",
"ph",
".",
"peers",
"[",
":",
"lastIdx",
"]",
"\n",
"return",
"last",
"\n",
"}"
] |
// Pop implements the heap.Interface. Do NOT use this method directly.
// Use popPeer instead.
|
[
"Pop",
"implements",
"the",
"heap",
".",
"Interface",
".",
"Do",
"NOT",
"use",
"this",
"method",
"directly",
".",
"Use",
"popPeer",
"instead",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/peer/x/peerheap/heap.go#L72-L77
|
10,581 |
yarpc/yarpc-go
|
internal/crossdock/client/random/rand.go
|
Bytes
|
func Bytes(length int) []byte {
out := make([]byte, length)
if _, err := io.ReadFull(rand.Reader, out); err != nil {
panic(err)
}
return out
}
|
go
|
func Bytes(length int) []byte {
out := make([]byte, length)
if _, err := io.ReadFull(rand.Reader, out); err != nil {
panic(err)
}
return out
}
|
[
"func",
"Bytes",
"(",
"length",
"int",
")",
"[",
"]",
"byte",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"length",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"rand",
".",
"Reader",
",",
"out",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] |
// Bytes generates the given number of random bytes.
|
[
"Bytes",
"generates",
"the",
"given",
"number",
"of",
"random",
"bytes",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/client/random/rand.go#L30-L36
|
10,582 |
yarpc/yarpc-go
|
internal/crossdock/client/random/rand.go
|
String
|
func String(length int) string {
return base64.RawStdEncoding.EncodeToString(Bytes(length))[:length]
}
|
go
|
func String(length int) string {
return base64.RawStdEncoding.EncodeToString(Bytes(length))[:length]
}
|
[
"func",
"String",
"(",
"length",
"int",
")",
"string",
"{",
"return",
"base64",
".",
"RawStdEncoding",
".",
"EncodeToString",
"(",
"Bytes",
"(",
"length",
")",
")",
"[",
":",
"length",
"]",
"\n",
"}"
] |
// String generates a random string of the given size.
|
[
"String",
"generates",
"a",
"random",
"string",
"of",
"the",
"given",
"size",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/internal/crossdock/client/random/rand.go#L39-L41
|
10,583 |
yarpc/yarpc-go
|
yarpcerrors/codes.go
|
String
|
func (c Code) String() string {
s, ok := _codeToString[c]
if ok {
return s
}
return strconv.Itoa(int(c))
}
|
go
|
func (c Code) String() string {
s, ok := _codeToString[c]
if ok {
return s
}
return strconv.Itoa(int(c))
}
|
[
"func",
"(",
"c",
"Code",
")",
"String",
"(",
")",
"string",
"{",
"s",
",",
"ok",
":=",
"_codeToString",
"[",
"c",
"]",
"\n",
"if",
"ok",
"{",
"return",
"s",
"\n",
"}",
"\n",
"return",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"c",
")",
")",
"\n",
"}"
] |
// String returns the the string representation of the Code.
|
[
"String",
"returns",
"the",
"the",
"string",
"representation",
"of",
"the",
"Code",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/yarpcerrors/codes.go#L194-L200
|
10,584 |
yarpc/yarpc-go
|
transport/http/outbound.go
|
NewSingleOutbound
|
func (t *Transport) NewSingleOutbound(uri string, opts ...OutboundOption) *Outbound {
parsedURL, err := url.Parse(uri)
if err != nil {
panic(err.Error())
}
chooser := peerchooser.NewSingle(hostport.PeerIdentifier(parsedURL.Host), t)
o := t.NewOutbound(chooser)
for _, opt := range opts {
opt(o)
}
o.setURLTemplate(uri)
return o
}
|
go
|
func (t *Transport) NewSingleOutbound(uri string, opts ...OutboundOption) *Outbound {
parsedURL, err := url.Parse(uri)
if err != nil {
panic(err.Error())
}
chooser := peerchooser.NewSingle(hostport.PeerIdentifier(parsedURL.Host), t)
o := t.NewOutbound(chooser)
for _, opt := range opts {
opt(o)
}
o.setURLTemplate(uri)
return o
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"NewSingleOutbound",
"(",
"uri",
"string",
",",
"opts",
"...",
"OutboundOption",
")",
"*",
"Outbound",
"{",
"parsedURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"uri",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"chooser",
":=",
"peerchooser",
".",
"NewSingle",
"(",
"hostport",
".",
"PeerIdentifier",
"(",
"parsedURL",
".",
"Host",
")",
",",
"t",
")",
"\n",
"o",
":=",
"t",
".",
"NewOutbound",
"(",
"chooser",
")",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"o",
")",
"\n",
"}",
"\n",
"o",
".",
"setURLTemplate",
"(",
"uri",
")",
"\n",
"return",
"o",
"\n",
"}"
] |
// NewSingleOutbound builds an outbound that sends YARPC requests over HTTP
// to the specified URL.
//
// The URLTemplate option has no effect in this form.
|
[
"NewSingleOutbound",
"builds",
"an",
"outbound",
"that",
"sends",
"YARPC",
"requests",
"over",
"HTTP",
"to",
"the",
"specified",
"URL",
".",
"The",
"URLTemplate",
"option",
"has",
"no",
"effect",
"in",
"this",
"form",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/http/outbound.go#L135-L148
|
10,585 |
yarpc/yarpc-go
|
transport/http/outbound.go
|
Call
|
func (o *Outbound) Call(ctx context.Context, treq *transport.Request) (*transport.Response, error) {
if treq == nil {
return nil, yarpcerrors.InvalidArgumentErrorf("request for http unary outbound was nil")
}
return o.call(ctx, treq)
}
|
go
|
func (o *Outbound) Call(ctx context.Context, treq *transport.Request) (*transport.Response, error) {
if treq == nil {
return nil, yarpcerrors.InvalidArgumentErrorf("request for http unary outbound was nil")
}
return o.call(ctx, treq)
}
|
[
"func",
"(",
"o",
"*",
"Outbound",
")",
"Call",
"(",
"ctx",
"context",
".",
"Context",
",",
"treq",
"*",
"transport",
".",
"Request",
")",
"(",
"*",
"transport",
".",
"Response",
",",
"error",
")",
"{",
"if",
"treq",
"==",
"nil",
"{",
"return",
"nil",
",",
"yarpcerrors",
".",
"InvalidArgumentErrorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"o",
".",
"call",
"(",
"ctx",
",",
"treq",
")",
"\n",
"}"
] |
// Call makes a HTTP request
|
[
"Call",
"makes",
"a",
"HTTP",
"request"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/http/outbound.go#L208-L214
|
10,586 |
yarpc/yarpc-go
|
transport/http/outbound.go
|
CallOneway
|
func (o *Outbound) CallOneway(ctx context.Context, treq *transport.Request) (transport.Ack, error) {
if treq == nil {
return nil, yarpcerrors.InvalidArgumentErrorf("request for http oneway outbound was nil")
}
_, err := o.call(ctx, treq)
if err != nil {
return nil, err
}
return time.Now(), nil
}
|
go
|
func (o *Outbound) CallOneway(ctx context.Context, treq *transport.Request) (transport.Ack, error) {
if treq == nil {
return nil, yarpcerrors.InvalidArgumentErrorf("request for http oneway outbound was nil")
}
_, err := o.call(ctx, treq)
if err != nil {
return nil, err
}
return time.Now(), nil
}
|
[
"func",
"(",
"o",
"*",
"Outbound",
")",
"CallOneway",
"(",
"ctx",
"context",
".",
"Context",
",",
"treq",
"*",
"transport",
".",
"Request",
")",
"(",
"transport",
".",
"Ack",
",",
"error",
")",
"{",
"if",
"treq",
"==",
"nil",
"{",
"return",
"nil",
",",
"yarpcerrors",
".",
"InvalidArgumentErrorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
":=",
"o",
".",
"call",
"(",
"ctx",
",",
"treq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"time",
".",
"Now",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// CallOneway makes a oneway request
|
[
"CallOneway",
"makes",
"a",
"oneway",
"request"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/http/outbound.go#L217-L228
|
10,587 |
yarpc/yarpc-go
|
transport/http/outbound.go
|
checkServiceMatch
|
func checkServiceMatch(reqSvcName string, resHeaders http.Header) (bool, string) {
serviceName := resHeaders.Get(ServiceHeader)
return serviceName == "" || serviceName == reqSvcName, serviceName
}
|
go
|
func checkServiceMatch(reqSvcName string, resHeaders http.Header) (bool, string) {
serviceName := resHeaders.Get(ServiceHeader)
return serviceName == "" || serviceName == reqSvcName, serviceName
}
|
[
"func",
"checkServiceMatch",
"(",
"reqSvcName",
"string",
",",
"resHeaders",
"http",
".",
"Header",
")",
"(",
"bool",
",",
"string",
")",
"{",
"serviceName",
":=",
"resHeaders",
".",
"Get",
"(",
"ServiceHeader",
")",
"\n",
"return",
"serviceName",
"==",
"\"",
"\"",
"||",
"serviceName",
"==",
"reqSvcName",
",",
"serviceName",
"\n",
"}"
] |
// Only does verification if there is a response header
|
[
"Only",
"does",
"verification",
"if",
"there",
"is",
"a",
"response",
"header"
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/transport/http/outbound.go#L412-L415
|
10,588 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
String
|
func (v *RPC) String() string {
if v == nil {
return "<nil>"
}
var fields [10]string
i := 0
fields[i] = fmt.Sprintf("SpanContext: %v", v.SpanContext)
i++
fields[i] = fmt.Sprintf("CallerName: %v", v.CallerName)
i++
fields[i] = fmt.Sprintf("ServiceName: %v", v.ServiceName)
i++
fields[i] = fmt.Sprintf("Encoding: %v", v.Encoding)
i++
fields[i] = fmt.Sprintf("Procedure: %v", v.Procedure)
i++
if v.Headers != nil {
fields[i] = fmt.Sprintf("Headers: %v", v.Headers)
i++
}
if v.ShardKey != nil {
fields[i] = fmt.Sprintf("ShardKey: %v", *(v.ShardKey))
i++
}
if v.RoutingKey != nil {
fields[i] = fmt.Sprintf("RoutingKey: %v", *(v.RoutingKey))
i++
}
if v.RoutingDelegate != nil {
fields[i] = fmt.Sprintf("RoutingDelegate: %v", *(v.RoutingDelegate))
i++
}
if v.Body != nil {
fields[i] = fmt.Sprintf("Body: %v", v.Body)
i++
}
return fmt.Sprintf("RPC{%v}", strings.Join(fields[:i], ", "))
}
|
go
|
func (v *RPC) String() string {
if v == nil {
return "<nil>"
}
var fields [10]string
i := 0
fields[i] = fmt.Sprintf("SpanContext: %v", v.SpanContext)
i++
fields[i] = fmt.Sprintf("CallerName: %v", v.CallerName)
i++
fields[i] = fmt.Sprintf("ServiceName: %v", v.ServiceName)
i++
fields[i] = fmt.Sprintf("Encoding: %v", v.Encoding)
i++
fields[i] = fmt.Sprintf("Procedure: %v", v.Procedure)
i++
if v.Headers != nil {
fields[i] = fmt.Sprintf("Headers: %v", v.Headers)
i++
}
if v.ShardKey != nil {
fields[i] = fmt.Sprintf("ShardKey: %v", *(v.ShardKey))
i++
}
if v.RoutingKey != nil {
fields[i] = fmt.Sprintf("RoutingKey: %v", *(v.RoutingKey))
i++
}
if v.RoutingDelegate != nil {
fields[i] = fmt.Sprintf("RoutingDelegate: %v", *(v.RoutingDelegate))
i++
}
if v.Body != nil {
fields[i] = fmt.Sprintf("Body: %v", v.Body)
i++
}
return fmt.Sprintf("RPC{%v}", strings.Join(fields[:i], ", "))
}
|
[
"func",
"(",
"v",
"*",
"RPC",
")",
"String",
"(",
")",
"string",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"var",
"fields",
"[",
"10",
"]",
"string",
"\n",
"i",
":=",
"0",
"\n",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"SpanContext",
")",
"\n",
"i",
"++",
"\n",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"CallerName",
")",
"\n",
"i",
"++",
"\n",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"ServiceName",
")",
"\n",
"i",
"++",
"\n",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"Encoding",
")",
"\n",
"i",
"++",
"\n",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"Procedure",
")",
"\n",
"i",
"++",
"\n",
"if",
"v",
".",
"Headers",
"!=",
"nil",
"{",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"Headers",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"if",
"v",
".",
"ShardKey",
"!=",
"nil",
"{",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"(",
"v",
".",
"ShardKey",
")",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"if",
"v",
".",
"RoutingKey",
"!=",
"nil",
"{",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"(",
"v",
".",
"RoutingKey",
")",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"if",
"v",
".",
"RoutingDelegate",
"!=",
"nil",
"{",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"*",
"(",
"v",
".",
"RoutingDelegate",
")",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"if",
"v",
".",
"Body",
"!=",
"nil",
"{",
"fields",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"Body",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"fields",
"[",
":",
"i",
"]",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// String returns a readable string representation of a RPC
// struct.
|
[
"String",
"returns",
"a",
"readable",
"string",
"representation",
"of",
"a",
"RPC",
"struct",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L359-L398
|
10,589 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
Equals
|
func (v *RPC) Equals(rhs *RPC) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !bytes.Equal(v.SpanContext, rhs.SpanContext) {
return false
}
if !(v.CallerName == rhs.CallerName) {
return false
}
if !(v.ServiceName == rhs.ServiceName) {
return false
}
if !(v.Encoding == rhs.Encoding) {
return false
}
if !(v.Procedure == rhs.Procedure) {
return false
}
if !((v.Headers == nil && rhs.Headers == nil) || (v.Headers != nil && rhs.Headers != nil && _Map_String_String_Equals(v.Headers, rhs.Headers))) {
return false
}
if !_String_EqualsPtr(v.ShardKey, rhs.ShardKey) {
return false
}
if !_String_EqualsPtr(v.RoutingKey, rhs.RoutingKey) {
return false
}
if !_String_EqualsPtr(v.RoutingDelegate, rhs.RoutingDelegate) {
return false
}
if !((v.Body == nil && rhs.Body == nil) || (v.Body != nil && rhs.Body != nil && bytes.Equal(v.Body, rhs.Body))) {
return false
}
return true
}
|
go
|
func (v *RPC) Equals(rhs *RPC) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !bytes.Equal(v.SpanContext, rhs.SpanContext) {
return false
}
if !(v.CallerName == rhs.CallerName) {
return false
}
if !(v.ServiceName == rhs.ServiceName) {
return false
}
if !(v.Encoding == rhs.Encoding) {
return false
}
if !(v.Procedure == rhs.Procedure) {
return false
}
if !((v.Headers == nil && rhs.Headers == nil) || (v.Headers != nil && rhs.Headers != nil && _Map_String_String_Equals(v.Headers, rhs.Headers))) {
return false
}
if !_String_EqualsPtr(v.ShardKey, rhs.ShardKey) {
return false
}
if !_String_EqualsPtr(v.RoutingKey, rhs.RoutingKey) {
return false
}
if !_String_EqualsPtr(v.RoutingDelegate, rhs.RoutingDelegate) {
return false
}
if !((v.Body == nil && rhs.Body == nil) || (v.Body != nil && rhs.Body != nil && bytes.Equal(v.Body, rhs.Body))) {
return false
}
return true
}
|
[
"func",
"(",
"v",
"*",
"RPC",
")",
"Equals",
"(",
"rhs",
"*",
"RPC",
")",
"bool",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"rhs",
"==",
"nil",
"\n",
"}",
"else",
"if",
"rhs",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"bytes",
".",
"Equal",
"(",
"v",
".",
"SpanContext",
",",
"rhs",
".",
"SpanContext",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"v",
".",
"CallerName",
"==",
"rhs",
".",
"CallerName",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"v",
".",
"ServiceName",
"==",
"rhs",
".",
"ServiceName",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"v",
".",
"Encoding",
"==",
"rhs",
".",
"Encoding",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"v",
".",
"Procedure",
"==",
"rhs",
".",
"Procedure",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"(",
"v",
".",
"Headers",
"==",
"nil",
"&&",
"rhs",
".",
"Headers",
"==",
"nil",
")",
"||",
"(",
"v",
".",
"Headers",
"!=",
"nil",
"&&",
"rhs",
".",
"Headers",
"!=",
"nil",
"&&",
"_Map_String_String_Equals",
"(",
"v",
".",
"Headers",
",",
"rhs",
".",
"Headers",
")",
")",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"_String_EqualsPtr",
"(",
"v",
".",
"ShardKey",
",",
"rhs",
".",
"ShardKey",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"_String_EqualsPtr",
"(",
"v",
".",
"RoutingKey",
",",
"rhs",
".",
"RoutingKey",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"_String_EqualsPtr",
"(",
"v",
".",
"RoutingDelegate",
",",
"rhs",
".",
"RoutingDelegate",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"(",
"(",
"v",
".",
"Body",
"==",
"nil",
"&&",
"rhs",
".",
"Body",
"==",
"nil",
")",
"||",
"(",
"v",
".",
"Body",
"!=",
"nil",
"&&",
"rhs",
".",
"Body",
"!=",
"nil",
"&&",
"bytes",
".",
"Equal",
"(",
"v",
".",
"Body",
",",
"rhs",
".",
"Body",
")",
")",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Equals returns true if all the fields of this RPC match the
// provided RPC.
//
// This function performs a deep comparison.
|
[
"Equals",
"returns",
"true",
"if",
"all",
"the",
"fields",
"of",
"this",
"RPC",
"match",
"the",
"provided",
"RPC",
".",
"This",
"function",
"performs",
"a",
"deep",
"comparison",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L431-L469
|
10,590 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
MarshalLogObject
|
func (m _Map_String_String_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
for k, v := range m {
enc.AddString((string)(k), v)
}
return err
}
|
go
|
func (m _Map_String_String_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
for k, v := range m {
enc.AddString((string)(k), v)
}
return err
}
|
[
"func",
"(",
"m",
"_Map_String_String_Zapper",
")",
"MarshalLogObject",
"(",
"enc",
"zapcore",
".",
"ObjectEncoder",
")",
"(",
"err",
"error",
")",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"m",
"{",
"enc",
".",
"AddString",
"(",
"(",
"string",
")",
"(",
"k",
")",
",",
"v",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of _Map_String_String_Zapper.
|
[
"MarshalLogObject",
"implements",
"zapcore",
".",
"ObjectMarshaler",
"enabling",
"fast",
"logging",
"of",
"_Map_String_String_Zapper",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L475-L480
|
10,591 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
MarshalLogObject
|
func (v *RPC) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
enc.AddString("spanContext", base64.StdEncoding.EncodeToString(v.SpanContext))
enc.AddString("callerName", v.CallerName)
enc.AddString("serviceName", v.ServiceName)
enc.AddString("encoding", v.Encoding)
enc.AddString("procedure", v.Procedure)
if v.Headers != nil {
err = multierr.Append(err, enc.AddObject("headers", (_Map_String_String_Zapper)(v.Headers)))
}
if v.ShardKey != nil {
enc.AddString("shardKey", *v.ShardKey)
}
if v.RoutingKey != nil {
enc.AddString("routingKey", *v.RoutingKey)
}
if v.RoutingDelegate != nil {
enc.AddString("routingDelegate", *v.RoutingDelegate)
}
if v.Body != nil {
enc.AddString("body", base64.StdEncoding.EncodeToString(v.Body))
}
return err
}
|
go
|
func (v *RPC) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
enc.AddString("spanContext", base64.StdEncoding.EncodeToString(v.SpanContext))
enc.AddString("callerName", v.CallerName)
enc.AddString("serviceName", v.ServiceName)
enc.AddString("encoding", v.Encoding)
enc.AddString("procedure", v.Procedure)
if v.Headers != nil {
err = multierr.Append(err, enc.AddObject("headers", (_Map_String_String_Zapper)(v.Headers)))
}
if v.ShardKey != nil {
enc.AddString("shardKey", *v.ShardKey)
}
if v.RoutingKey != nil {
enc.AddString("routingKey", *v.RoutingKey)
}
if v.RoutingDelegate != nil {
enc.AddString("routingDelegate", *v.RoutingDelegate)
}
if v.Body != nil {
enc.AddString("body", base64.StdEncoding.EncodeToString(v.Body))
}
return err
}
|
[
"func",
"(",
"v",
"*",
"RPC",
")",
"MarshalLogObject",
"(",
"enc",
"zapcore",
".",
"ObjectEncoder",
")",
"(",
"err",
"error",
")",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"v",
".",
"SpanContext",
")",
")",
"\n",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"v",
".",
"CallerName",
")",
"\n",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"v",
".",
"ServiceName",
")",
"\n",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"v",
".",
"Encoding",
")",
"\n",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"v",
".",
"Procedure",
")",
"\n",
"if",
"v",
".",
"Headers",
"!=",
"nil",
"{",
"err",
"=",
"multierr",
".",
"Append",
"(",
"err",
",",
"enc",
".",
"AddObject",
"(",
"\"",
"\"",
",",
"(",
"_Map_String_String_Zapper",
")",
"(",
"v",
".",
"Headers",
")",
")",
")",
"\n",
"}",
"\n",
"if",
"v",
".",
"ShardKey",
"!=",
"nil",
"{",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"*",
"v",
".",
"ShardKey",
")",
"\n",
"}",
"\n",
"if",
"v",
".",
"RoutingKey",
"!=",
"nil",
"{",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"*",
"v",
".",
"RoutingKey",
")",
"\n",
"}",
"\n",
"if",
"v",
".",
"RoutingDelegate",
"!=",
"nil",
"{",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"*",
"v",
".",
"RoutingDelegate",
")",
"\n",
"}",
"\n",
"if",
"v",
".",
"Body",
"!=",
"nil",
"{",
"enc",
".",
"AddString",
"(",
"\"",
"\"",
",",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"v",
".",
"Body",
")",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of RPC.
|
[
"MarshalLogObject",
"implements",
"zapcore",
".",
"ObjectMarshaler",
"enabling",
"fast",
"logging",
"of",
"RPC",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L484-L509
|
10,592 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
GetSpanContext
|
func (v *RPC) GetSpanContext() (o []byte) {
if v != nil {
o = v.SpanContext
}
return
}
|
go
|
func (v *RPC) GetSpanContext() (o []byte) {
if v != nil {
o = v.SpanContext
}
return
}
|
[
"func",
"(",
"v",
"*",
"RPC",
")",
"GetSpanContext",
"(",
")",
"(",
"o",
"[",
"]",
"byte",
")",
"{",
"if",
"v",
"!=",
"nil",
"{",
"o",
"=",
"v",
".",
"SpanContext",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// GetSpanContext returns the value of SpanContext if it is set or its
// zero value if it is unset.
|
[
"GetSpanContext",
"returns",
"the",
"value",
"of",
"SpanContext",
"if",
"it",
"is",
"set",
"or",
"its",
"zero",
"value",
"if",
"it",
"is",
"unset",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L513-L518
|
10,593 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
GetCallerName
|
func (v *RPC) GetCallerName() (o string) {
if v != nil {
o = v.CallerName
}
return
}
|
go
|
func (v *RPC) GetCallerName() (o string) {
if v != nil {
o = v.CallerName
}
return
}
|
[
"func",
"(",
"v",
"*",
"RPC",
")",
"GetCallerName",
"(",
")",
"(",
"o",
"string",
")",
"{",
"if",
"v",
"!=",
"nil",
"{",
"o",
"=",
"v",
".",
"CallerName",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// GetCallerName returns the value of CallerName if it is set or its
// zero value if it is unset.
|
[
"GetCallerName",
"returns",
"the",
"value",
"of",
"CallerName",
"if",
"it",
"is",
"set",
"or",
"its",
"zero",
"value",
"if",
"it",
"is",
"unset",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L527-L532
|
10,594 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
GetServiceName
|
func (v *RPC) GetServiceName() (o string) {
if v != nil {
o = v.ServiceName
}
return
}
|
go
|
func (v *RPC) GetServiceName() (o string) {
if v != nil {
o = v.ServiceName
}
return
}
|
[
"func",
"(",
"v",
"*",
"RPC",
")",
"GetServiceName",
"(",
")",
"(",
"o",
"string",
")",
"{",
"if",
"v",
"!=",
"nil",
"{",
"o",
"=",
"v",
".",
"ServiceName",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// GetServiceName returns the value of ServiceName if it is set or its
// zero value if it is unset.
|
[
"GetServiceName",
"returns",
"the",
"value",
"of",
"ServiceName",
"if",
"it",
"is",
"set",
"or",
"its",
"zero",
"value",
"if",
"it",
"is",
"unset",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L536-L541
|
10,595 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
GetEncoding
|
func (v *RPC) GetEncoding() (o string) {
if v != nil {
o = v.Encoding
}
return
}
|
go
|
func (v *RPC) GetEncoding() (o string) {
if v != nil {
o = v.Encoding
}
return
}
|
[
"func",
"(",
"v",
"*",
"RPC",
")",
"GetEncoding",
"(",
")",
"(",
"o",
"string",
")",
"{",
"if",
"v",
"!=",
"nil",
"{",
"o",
"=",
"v",
".",
"Encoding",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// GetEncoding returns the value of Encoding if it is set or its
// zero value if it is unset.
|
[
"GetEncoding",
"returns",
"the",
"value",
"of",
"Encoding",
"if",
"it",
"is",
"set",
"or",
"its",
"zero",
"value",
"if",
"it",
"is",
"unset",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L545-L550
|
10,596 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
GetProcedure
|
func (v *RPC) GetProcedure() (o string) {
if v != nil {
o = v.Procedure
}
return
}
|
go
|
func (v *RPC) GetProcedure() (o string) {
if v != nil {
o = v.Procedure
}
return
}
|
[
"func",
"(",
"v",
"*",
"RPC",
")",
"GetProcedure",
"(",
")",
"(",
"o",
"string",
")",
"{",
"if",
"v",
"!=",
"nil",
"{",
"o",
"=",
"v",
".",
"Procedure",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// GetProcedure returns the value of Procedure if it is set or its
// zero value if it is unset.
|
[
"GetProcedure",
"returns",
"the",
"value",
"of",
"Procedure",
"if",
"it",
"is",
"set",
"or",
"its",
"zero",
"value",
"if",
"it",
"is",
"unset",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L554-L559
|
10,597 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
GetHeaders
|
func (v *RPC) GetHeaders() (o map[string]string) {
if v != nil && v.Headers != nil {
return v.Headers
}
return
}
|
go
|
func (v *RPC) GetHeaders() (o map[string]string) {
if v != nil && v.Headers != nil {
return v.Headers
}
return
}
|
[
"func",
"(",
"v",
"*",
"RPC",
")",
"GetHeaders",
"(",
")",
"(",
"o",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"if",
"v",
"!=",
"nil",
"&&",
"v",
".",
"Headers",
"!=",
"nil",
"{",
"return",
"v",
".",
"Headers",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// GetHeaders returns the value of Headers if it is set or its
// zero value if it is unset.
|
[
"GetHeaders",
"returns",
"the",
"value",
"of",
"Headers",
"if",
"it",
"is",
"set",
"or",
"its",
"zero",
"value",
"if",
"it",
"is",
"unset",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L563-L569
|
10,598 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
GetShardKey
|
func (v *RPC) GetShardKey() (o string) {
if v != nil && v.ShardKey != nil {
return *v.ShardKey
}
return
}
|
go
|
func (v *RPC) GetShardKey() (o string) {
if v != nil && v.ShardKey != nil {
return *v.ShardKey
}
return
}
|
[
"func",
"(",
"v",
"*",
"RPC",
")",
"GetShardKey",
"(",
")",
"(",
"o",
"string",
")",
"{",
"if",
"v",
"!=",
"nil",
"&&",
"v",
".",
"ShardKey",
"!=",
"nil",
"{",
"return",
"*",
"v",
".",
"ShardKey",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// GetShardKey returns the value of ShardKey if it is set or its
// zero value if it is unset.
|
[
"GetShardKey",
"returns",
"the",
"value",
"of",
"ShardKey",
"if",
"it",
"is",
"set",
"or",
"its",
"zero",
"value",
"if",
"it",
"is",
"unset",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L578-L584
|
10,599 |
yarpc/yarpc-go
|
serialize/internal/types.go
|
GetRoutingKey
|
func (v *RPC) GetRoutingKey() (o string) {
if v != nil && v.RoutingKey != nil {
return *v.RoutingKey
}
return
}
|
go
|
func (v *RPC) GetRoutingKey() (o string) {
if v != nil && v.RoutingKey != nil {
return *v.RoutingKey
}
return
}
|
[
"func",
"(",
"v",
"*",
"RPC",
")",
"GetRoutingKey",
"(",
")",
"(",
"o",
"string",
")",
"{",
"if",
"v",
"!=",
"nil",
"&&",
"v",
".",
"RoutingKey",
"!=",
"nil",
"{",
"return",
"*",
"v",
".",
"RoutingKey",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// GetRoutingKey returns the value of RoutingKey if it is set or its
// zero value if it is unset.
|
[
"GetRoutingKey",
"returns",
"the",
"value",
"of",
"RoutingKey",
"if",
"it",
"is",
"set",
"or",
"its",
"zero",
"value",
"if",
"it",
"is",
"unset",
"."
] |
bd70ffbd17e635243988ba62be97eebff738204d
|
https://github.com/yarpc/yarpc-go/blob/bd70ffbd17e635243988ba62be97eebff738204d/serialize/internal/types.go#L593-L599
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.