_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q10400 | Listen | train | func Listen(port uint32) (*Listener, error) {
cid, err := ContextID()
if err != nil {
// No addresses available.
return nil, opError(opListen, err, nil, nil)
}
l, err := listen(cid, port)
if err != nil {
// No remote address available.
return nil, opError(opListen, err, &Addr{
ContextID: cid,
Port: ... | go | {
"resource": ""
} |
q10401 | Close | train | func (l *Listener) Close() error {
return l.opError(opClose, l.l.Close())
} | go | {
"resource": ""
} |
q10402 | SetDeadline | train | func (l *Listener) SetDeadline(t time.Time) error {
return l.opError(opSet, l.l.SetDeadline(t))
} | go | {
"resource": ""
} |
q10403 | opError | train | func (l *Listener) opError(op string, err error) error {
// No remote address for a Listener.
return opError(op, err, l.Addr(), nil)
} | go | {
"resource": ""
} |
q10404 | Dial | train | func Dial(contextID, port uint32) (*Conn, error) {
c, err := dial(contextID, port)
if err != nil {
// No local address, but we have a remote address we can return.
return nil, opError(opDial, err, nil, &Addr{
ContextID: contextID,
Port: port,
})
}
return c, nil
} | go | {
"resource": ""
} |
q10405 | CloseRead | train | func (c *Conn) CloseRead() error {
return c.opError(opClose, c.fd.Shutdown(shutRd))
} | go | {
"resource": ""
} |
q10406 | CloseWrite | train | func (c *Conn) CloseWrite() error {
return c.opError(opClose, c.fd.Shutdown(shutWr))
} | go | {
"resource": ""
} |
q10407 | SyscallConn | train | func (c *Conn) SyscallConn() (syscall.RawConn, error) {
rc, err := c.fd.SyscallConn()
if err != nil {
return nil, c.opError(opSyscallConn, err)
}
return &rawConn{
rc: rc,
local: c.local,
remote: c.remote,
}, nil
} | go | {
"resource": ""
} |
q10408 | opError | train | func (c *Conn) opError(op string, err error) error {
return opError(op, err, c.local, c.remote)
} | go | {
"resource": ""
} |
q10409 | Control | train | func (rc *rawConn) Control(fn func(fd uintptr)) error {
return rc.opError(opRawControl, rc.rc.Control(fn))
} | go | {
"resource": ""
} |
q10410 | Read | train | func (rc *rawConn) Read(fn func(fd uintptr) (done bool)) error {
return rc.opError(opRawRead, rc.rc.Read(fn))
} | go | {
"resource": ""
} |
q10411 | Write | train | func (rc *rawConn) Write(fn func(fd uintptr) (done bool)) error {
return rc.opError(opRawWrite, rc.rc.Write(fn))
} | go | {
"resource": ""
} |
q10412 | opError | train | func (rc *rawConn) opError(op string, err error) error {
return opError(op, err, rc.local, rc.remote)
} | go | {
"resource": ""
} |
q10413 | String | train | func (a *Addr) String() string {
var host string
switch a.ContextID {
case Hypervisor:
host = fmt.Sprintf("hypervisor(%d)", a.ContextID)
case cidReserved:
host = fmt.Sprintf("reserved(%d)", a.ContextID)
case Host:
host = fmt.Sprintf("host(%d)", a.ContextID)
default:
host = fmt.Sprintf("vm(%d)", a.Context... | go | {
"resource": ""
} |
q10414 | fileName | train | func (a *Addr) fileName() string {
return fmt.Sprintf("%s:%s", a.Network(), a.String())
} | go | {
"resource": ""
} |
q10415 | opError | train | func opError(op string, err error, local, remote net.Addr) error {
if err == nil {
return nil
}
// Unwrap inner errors from error types.
//
// TODO(mdlayher): errors.Cause or similar in Go 1.13.
switch xerr := err.(type) {
// os.PathError produced by os.File method calls.
case *os.PathError:
// Although we... | go | {
"resource": ""
} |
q10416 | Accept | train | func (l *listener) Accept() (net.Conn, error) {
cfd, sa, err := l.fd.Accept4(0)
if err != nil {
return nil, err
}
savm := sa.(*unix.SockaddrVM)
remote := &Addr{
ContextID: savm.CID,
Port: savm.Port,
}
return newConn(cfd, l.addr, remote)
} | go | {
"resource": ""
} |
q10417 | listen | train | func listen(cid, port uint32) (*Listener, error) {
lfd, err := newListenFD()
if err != nil {
return nil, err
}
return listenLinux(lfd, cid, port)
} | go | {
"resource": ""
} |
q10418 | listenLinux | train | func listenLinux(lfd listenFD, cid, port uint32) (l *Listener, err error) {
defer func() {
if err != nil {
// If any system calls fail during setup, the socket must be closed
// to avoid file descriptor leaks.
_ = lfd.EarlyClose()
}
}()
// Zero-value for "any port" is friendlier in Go than a constant.
... | go | {
"resource": ""
} |
q10419 | newListenFD | train | func newListenFD() (*sysListenFD, error) {
fd, err := unix.Socket(unix.AF_VSOCK, unix.SOCK_STREAM, 0)
if err != nil {
return nil, err
}
return &sysListenFD{
fd: fd,
}, nil
} | go | {
"resource": ""
} |
q10420 | Accept4 | train | func (lfd *sysListenFD) Accept4(flags int) (connFD, unix.Sockaddr, error) {
// Invoke Go version-specific logic for accept.
newFD, sa, err := lfd.accept4(flags)
if err != nil {
return nil, nil, err
}
// Create a non-blocking connFD which will be used to implement net.Conn.
cfd := &sysConnFD{fd: newFD}
return ... | go | {
"resource": ""
} |
q10421 | newConnFD | train | func newConnFD() (*sysConnFD, error) {
fd, err := unix.Socket(unix.AF_VSOCK, unix.SOCK_STREAM, 0)
if err != nil {
return nil, err
}
return &sysConnFD{
fd: fd,
}, nil
} | go | {
"resource": ""
} |
q10422 | isErrno | train | func isErrno(err error, errno int) bool {
switch errno {
case ebadf:
return err == unix.EBADF
case enotconn:
return err == unix.ENOTCONN
default:
panicf("vsock: isErrno called with unhandled error number parameter: %d", errno)
return false
}
} | go | {
"resource": ""
} |
q10423 | newConn | train | func newConn(cfd connFD, local, remote *Addr) (*Conn, error) {
// Note: if any calls fail after this point, cfd.Close should be invoked
// for cleanup because the socket is now non-blocking.
if err := cfd.SetNonblocking(local.fileName()); err != nil {
return nil, err
}
return &Conn{
fd: cfd,
local: loc... | go | {
"resource": ""
} |
q10424 | dial | train | func dial(cid, port uint32) (*Conn, error) {
cfd, err := newConnFD()
if err != nil {
return nil, err
}
return dialLinux(cfd, cid, port)
} | go | {
"resource": ""
} |
q10425 | dialLinux | train | func dialLinux(cfd connFD, cid, port uint32) (c *Conn, err error) {
defer func() {
if err != nil {
// If any system calls fail during setup, the socket must be closed
// to avoid file descriptor leaks.
_ = cfd.EarlyClose()
}
}()
rsa := &unix.SockaddrVM{
CID: cid,
Port: port,
}
if err := cfd.Con... | go | {
"resource": ""
} |
q10426 | receive | train | func receive(target string, port uint32, timeout time.Duration, checksum bool) {
// Log helper functions.
logf := func(format string, a ...interface{}) {
logf("receive: "+format, a...)
}
fatalf := func(format string, a ...interface{}) {
log.Fatalf("vscp: receive: "+format, a...)
}
// Determine if target is ... | go | {
"resource": ""
} |
q10427 | send | train | func send(target string, cid, port uint32, checksum bool) {
// Log helper functions.
logf := func(format string, a ...interface{}) {
logf("send: "+format, a...)
}
fatalf := func(format string, a ...interface{}) {
log.Fatalf("vscp: send: "+format, a...)
}
// Determine if target is stdin or a file to be read ... | go | {
"resource": ""
} |
q10428 | skipOnConnRefused | train | func skipOnConnRefused(t crossdock.T, err error) bool {
switch err.(type) {
case *net.OpError:
t.Skipf("tchannel server not implemented: %v", err)
return true
}
return false
} | go | {
"resource": ""
} |
q10429 | Copy | train | func Copy(dst io.Writer, src io.Reader) (int64, error) {
// To avoid unnecessary memory allocations we maintain our own pool of
// buffers.
buf := _pool.Get().(*buffer)
written, err := io.CopyBuffer(dst, src, buf.b)
_pool.Put(buf)
return written, err
} | go | {
"resource": ""
} |
q10430 | NewHeadersWithCapacity | train | func NewHeadersWithCapacity(capacity int) Headers {
if capacity <= 0 {
return Headers{}
}
return Headers{
items: make(map[string]string, capacity),
originalItems: make(map[string]string, capacity),
}
} | go | {
"resource": ""
} |
q10431 | Del | train | func (h Headers) Del(k string) {
delete(h.items, CanonicalizeHeaderKey(k))
delete(h.originalItems, k)
} | go | {
"resource": ""
} |
q10432 | Get | train | func (h Headers) Get(k string) (string, bool) {
v, ok := h.items[CanonicalizeHeaderKey(k)]
return v, ok
} | go | {
"resource": ""
} |
q10433 | HeadersFromMap | train | func HeadersFromMap(m map[string]string) Headers {
if len(m) == 0 {
return Headers{}
}
headers := NewHeadersWithCapacity(len(m))
for k, v := range m {
headers = headers.With(k, v)
}
return headers
} | go | {
"resource": ""
} |
q10434 | Capacity | train | func Capacity(capacity int) ListOption {
return listOptionFunc(func(options *listOptions) {
options.capacity = capacity
})
} | go | {
"resource": ""
} |
q10435 | Seed | train | func Seed(seed int64) ListOption {
return listOptionFunc(func(options *listOptions) {
options.seed = seed
})
} | go | {
"resource": ""
} |
q10436 | Update | train | func (pl *List) Update(updates peer.ListUpdates) error {
if len(updates.Additions) == 0 && len(updates.Removals) == 0 {
return nil
}
pl.lock.Lock()
defer pl.lock.Unlock()
if pl.shouldRetainPeers.Load() {
return pl.updateInitialized(updates)
}
return pl.updateUninitialized(updates)
} | go | {
"resource": ""
} |
q10437 | stop | train | func (pl *List) stop() error {
pl.lock.Lock()
defer pl.lock.Unlock()
var errs error
if err := pl.availableChooser.Stop(); err != nil {
errs = multierr.Append(errs, err)
}
availablePeers := pl.removeAllAvailablePeers(pl.availablePeers)
errs = pl.releaseAll(errs, availablePeers)
pl.addToUninitialized(availab... | go | {
"resource": ""
} |
q10438 | releaseAll | train | func (pl *List) releaseAll(errs error, peers []*peerThunk) error {
for _, t := range peers {
if err := pl.transport.ReleasePeer(t.peer, t); err != nil {
errs = multierr.Append(errs, err)
}
}
return errs
} | go | {
"resource": ""
} |
q10439 | Choose | train | func (pl *List) Choose(ctx context.Context, req *transport.Request) (peer.Peer, func(error), error) {
if err := pl.once.WaitUntilRunning(ctx); err != nil {
return nil, nil, intyarpcerrors.AnnotateWithInfo(yarpcerrors.FromError(err), "%s peer list is not running", pl.name)
}
for {
pl.lock.Lock()
p := pl.availa... | go | {
"resource": ""
} |
q10440 | NotifyStatusChanged | train | func (pl *List) NotifyStatusChanged(pid peer.Identifier) {
pl.lock.RLock()
t := pl.getThunk(pid)
pl.lock.RUnlock()
if t != nil {
t.NotifyStatusChanged(t.id)
}
} | go | {
"resource": ""
} |
q10441 | getThunk | train | func (pl *List) getThunk(pid peer.Identifier) *peerThunk {
if t := pl.availablePeers[pid.Identifier()]; t != nil {
return t
}
return pl.unavailablePeers[pid.Identifier()]
} | go | {
"resource": ""
} |
q10442 | notifyStatusChanged | train | func (pl *List) notifyStatusChanged(pid peer.Identifier) {
pl.lock.Lock()
defer pl.lock.Unlock()
if t := pl.availablePeers[pid.Identifier()]; t != nil {
// TODO: log error
_ = pl.handleAvailablePeerStatusChange(t)
return
}
if t := pl.unavailablePeers[pid.Identifier()]; t != nil {
// TODO: log error
_ =... | go | {
"resource": ""
} |
q10443 | Available | train | func (pl *List) Available(p peer.Identifier) bool {
_, ok := pl.availablePeers[p.Identifier()]
return ok
} | go | {
"resource": ""
} |
q10444 | Uninitialized | train | func (pl *List) Uninitialized(p peer.Identifier) bool {
_, ok := pl.uninitializedPeers[p.Identifier()]
return ok
} | go | {
"resource": ""
} |
q10445 | Introspect | train | func (pl *List) Introspect() introspection.ChooserStatus {
state := "Stopped"
if pl.IsRunning() {
state = "Running"
}
pl.lock.Lock()
availables := make([]peer.Peer, 0, len(pl.availablePeers))
for _, t := range pl.availablePeers {
availables = append(availables, t.peer)
}
unavailables := make([]peer.Peer, 0... | go | {
"resource": ""
} |
q10446 | values | train | func values(m map[string]peer.Identifier) []peer.Identifier {
vs := make([]peer.Identifier, 0, len(m))
for _, v := range m {
vs = append(vs, v)
}
return vs
} | go | {
"resource": ""
} |
q10447 | String | train | func (v *KeyValue_GetValue_Args) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Key != nil {
fields[i] = fmt.Sprintf("Key: %v", *(v.Key))
i++
}
return fmt.Sprintf("KeyValue_GetValue_Args{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10448 | Equals | train | func (v *KeyValue_GetValue_Args) Equals(rhs *KeyValue_GetValue_Args) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_String_EqualsPtr(v.Key, rhs.Key) {
return false
}
return true
} | go | {
"resource": ""
} |
q10449 | MarshalLogObject | train | func (v *KeyValue_GetValue_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Key != nil {
enc.AddString("key", *v.Key)
}
return err
} | go | {
"resource": ""
} |
q10450 | String | train | func (v *KeyValue_GetValue_Result) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
if v.Success != nil {
fields[i] = fmt.Sprintf("Success: %v", *(v.Success))
i++
}
if v.DoesNotExist != nil {
fields[i] = fmt.Sprintf("DoesNotExist: %v", v.DoesNotExist)
i++
}
return fmt.Sp... | go | {
"resource": ""
} |
q10451 | Equals | train | func (v *KeyValue_GetValue_Result) Equals(rhs *KeyValue_GetValue_Result) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_String_EqualsPtr(v.Success, rhs.Success) {
return false
}
if !((v.DoesNotExist == nil && rhs.DoesNotExist == nil) || (v.DoesNotExist != nil && rhs.DoesNo... | go | {
"resource": ""
} |
q10452 | MarshalLogObject | train | func (v *KeyValue_GetValue_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Success != nil {
enc.AddString("success", *v.Success)
}
if v.DoesNotExist != nil {
err = multierr.Append(err, enc.AddObject("doesNotExist", v.DoesNotExist))
}
return err
} | go | {
"resource": ""
} |
q10453 | GetDoesNotExist | train | func (v *KeyValue_GetValue_Result) GetDoesNotExist() (o *ResourceDoesNotExist) {
if v != nil && v.DoesNotExist != nil {
return v.DoesNotExist
}
return
} | go | {
"resource": ""
} |
q10454 | String | train | func (v *Oneway_Echo_Args) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Token != nil {
fields[i] = fmt.Sprintf("Token: %v", *(v.Token))
i++
}
return fmt.Sprintf("Oneway_Echo_Args{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10455 | Equals | train | func (v *Oneway_Echo_Args) Equals(rhs *Oneway_Echo_Args) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_String_EqualsPtr(v.Token, rhs.Token) {
return false
}
return true
} | go | {
"resource": ""
} |
q10456 | MarshalLogObject | train | func (v *Oneway_Echo_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Token != nil {
enc.AddString("token", *v.Token)
}
return err
} | go | {
"resource": ""
} |
q10457 | GetToken | train | func (v *Oneway_Echo_Args) GetToken() (o string) {
if v != nil && v.Token != nil {
return *v.Token
}
return
} | go | {
"resource": ""
} |
q10458 | WithClients | train | func WithClients(
transportType testutils.TransportType,
keyValueYARPCServer examplepb.KeyValueYARPCServer,
sinkYARPCServer examplepb.SinkYARPCServer,
fooYARPCServer examplepb.FooYARPCServer,
logger *zap.Logger,
f func(*Clients) error,
) error {
var procedures []transport.Procedure
if keyValueYARPCServer != nil... | go | {
"resource": ""
} |
q10459 | NewWithNamef | train | func NewWithNamef(code yarpcerrors.Code, name string, format string, args ...interface{}) *yarpcerrors.Status {
return yarpcerrors.Newf(code, format, args...).WithName(name)
} | go | {
"resource": ""
} |
q10460 | AnnotateWithInfo | train | func AnnotateWithInfo(status *yarpcerrors.Status, format string, args ...interface{}) *yarpcerrors.Status {
return yarpcerrors.Newf(status.Code(), "%s: %s", fmt.Sprintf(format, args...), status.Message())
} | go | {
"resource": ""
} |
q10461 | Run | train | func Run(t crossdock.T) {
fatals := crossdock.Fatals(t)
encoding := t.Param(params.Encoding)
server := t.Param(params.Server)
serverHostPort := fmt.Sprintf("%v:%v", server, serverPort)
ch, err := tchannel.NewChannel("tchannel-client", nil)
fatals.NoError(err, "Could not create channel")
call := call{Channel: ... | go | {
"resource": ""
} |
q10462 | NewMiddleware | train | func NewMiddleware(cfg Config) *Middleware {
m := &Middleware{newGraph(cfg.Scope, cfg.Logger, cfg.ContextExtractor)}
if lvl := cfg.SuccessLevel; lvl != nil {
m.graph.succLevel = *lvl
}
if lvl := cfg.FailureLevel; lvl != nil {
m.graph.failLevel = *lvl
}
if lvl := cfg.ApplicationErrorLevel; lvl != nil {
m.gr... | go | {
"resource": ""
} |
q10463 | Handle | train | func (m *Middleware) Handle(ctx context.Context, req *transport.Request, w transport.ResponseWriter, h transport.UnaryHandler) error {
call := m.graph.begin(ctx, transport.Unary, _directionInbound, req)
wrappedWriter := newWriter(w)
err := h.Handle(ctx, req, wrappedWriter)
call.EndWithAppError(err, wrappedWriter.is... | go | {
"resource": ""
} |
q10464 | Call | train | func (m *Middleware) Call(ctx context.Context, req *transport.Request, out transport.UnaryOutbound) (*transport.Response, error) {
call := m.graph.begin(ctx, transport.Unary, _directionOutbound, req)
res, err := out.Call(ctx, req)
isApplicationError := false
if res != nil {
isApplicationError = res.ApplicationEr... | go | {
"resource": ""
} |
q10465 | HandleOneway | train | func (m *Middleware) HandleOneway(ctx context.Context, req *transport.Request, h transport.OnewayHandler) error {
call := m.graph.begin(ctx, transport.Oneway, _directionInbound, req)
err := h.HandleOneway(ctx, req)
call.End(err)
return err
} | go | {
"resource": ""
} |
q10466 | CallOneway | train | func (m *Middleware) CallOneway(ctx context.Context, req *transport.Request, out transport.OnewayOutbound) (transport.Ack, error) {
call := m.graph.begin(ctx, transport.Oneway, _directionOutbound, req)
ack, err := out.CallOneway(ctx, req)
call.End(err)
return ack, err
} | go | {
"resource": ""
} |
q10467 | HandleStream | train | func (m *Middleware) HandleStream(serverStream *transport.ServerStream, h transport.StreamHandler) error {
call := m.graph.begin(serverStream.Context(), transport.Streaming, _directionInbound, serverStream.Request().Meta.ToRequest())
err := h.HandleStream(serverStream)
// TODO(pedge): wrap the *transport.ServerStrea... | go | {
"resource": ""
} |
q10468 | CallStream | train | func (m *Middleware) CallStream(ctx context.Context, request *transport.StreamRequest, out transport.StreamOutbound) (*transport.ClientStream, error) {
call := m.graph.begin(ctx, transport.Streaming, _directionOutbound, request.Meta.ToRequest())
clientStream, err := out.CallStream(ctx, request)
// TODO(pedge): wrap ... | go | {
"resource": ""
} |
q10469 | RequestBodyDecodeError | train | func RequestBodyDecodeError(req *transport.Request, err error) error {
return newServerEncodingError(req, nil, false /*isResponse*/, false /*isHeader*/, err)
} | go | {
"resource": ""
} |
q10470 | ResponseBodyEncodeError | train | func ResponseBodyEncodeError(req *transport.Request, err error) error {
return newServerEncodingError(req, nil, true /*isResponse*/, false /*isHeader*/, err)
} | go | {
"resource": ""
} |
q10471 | ResponseHeadersEncodeError | train | func ResponseHeadersEncodeError(req *transport.Request, err error) error {
return newServerEncodingError(req, nil, true /*isResponse*/, true /*isHeader*/, err)
} | go | {
"resource": ""
} |
q10472 | ExpectEncodings | train | func ExpectEncodings(req *transport.Request, want ...transport.Encoding) error {
got := req.Encoding
for _, w := range want {
if w == got {
return nil
}
}
return newServerEncodingError(req, want, false /*isResponse*/, false /*isHeader*/, newEncodingMismatchError(want, got))
} | go | {
"resource": ""
} |
q10473 | ApplyUnaryInbound | train | func ApplyUnaryInbound(h transport.UnaryHandler, i UnaryInbound) transport.UnaryHandler {
if i == nil {
return h
}
return unaryHandlerWithMiddleware{h: h, i: i}
} | go | {
"resource": ""
} |
q10474 | Handle | train | func (f UnaryInboundFunc) Handle(ctx context.Context, req *transport.Request, resw transport.ResponseWriter, h transport.UnaryHandler) error {
return f(ctx, req, resw, h)
} | go | {
"resource": ""
} |
q10475 | ApplyOnewayInbound | train | func ApplyOnewayInbound(h transport.OnewayHandler, i OnewayInbound) transport.OnewayHandler {
if i == nil {
return h
}
return onewayHandlerWithMiddleware{h: h, i: i}
} | go | {
"resource": ""
} |
q10476 | HandleOneway | train | func (f OnewayInboundFunc) HandleOneway(ctx context.Context, req *transport.Request, h transport.OnewayHandler) error {
return f(ctx, req, h)
} | go | {
"resource": ""
} |
q10477 | ApplyStreamInbound | train | func ApplyStreamInbound(h transport.StreamHandler, i StreamInbound) transport.StreamHandler {
if i == nil {
return h
}
return streamHandlerWithMiddleware{h: h, i: i}
} | go | {
"resource": ""
} |
q10478 | HandleStream | train | func (f StreamInboundFunc) HandleStream(s *transport.ServerStream, h transport.StreamHandler) error {
return f(s, h)
} | go | {
"resource": ""
} |
q10479 | New | train | func New(c Config, opts ...ClientOption) Client {
// Code generated for Thrift client instantiation will probably be something
// like this:
//
// func New(cc transport.ClientConfig, opts ...ClientOption) *MyServiceClient {
// c := thrift.New(thrift.Config{
// Service: "MyService",
// ClientConfig: cc,
... | go | {
"resource": ""
} |
q10480 | ValidateRequest | train | func ValidateRequest(req *Request) error {
var missingParams []string
if req.Service == "" {
missingParams = append(missingParams, "service name")
}
if req.Procedure == "" {
missingParams = append(missingParams, "procedure")
}
if req.Caller == "" {
missingParams = append(missingParams, "caller name")
}
if... | go | {
"resource": ""
} |
q10481 | ValidateRequestContext | train | func ValidateRequestContext(ctx context.Context) error {
if _, hasDeadline := ctx.Deadline(); !hasDeadline {
return yarpcerrors.Newf(yarpcerrors.CodeInvalidArgument, "missing TTL")
}
return nil
} | go | {
"resource": ""
} |
q10482 | ToRequest | train | func (r *RequestMeta) ToRequest() *Request {
if r == nil {
return &Request{}
}
return &Request{
Caller: r.Caller,
Service: r.Service,
Transport: r.Transport,
Encoding: r.Encoding,
Procedure: r.Procedure,
Headers: r.Headers,
ShardKey: r.ShardKey,
Ro... | go | {
"resource": ""
} |
q10483 | Start | train | func Start() {
mux := &yarpcHTTPMux{
handlers: make(map[string]http.Handler),
}
mux.HandleFunc("handlertimeout/raw", handlerTimeoutRawHandler)
server = net.NewHTTPServer(
&http.Server{
Addr: addr,
Handler: mux,
ReadTimeout: 5 * time.Second,
WriteTimeout: 5 * time.Second,
})
if err... | go | {
"resource": ""
} |
q10484 | getBasicTransportRequest | train | func (h *handler) getBasicTransportRequest(ctx context.Context, streamMethod string) (*transport.Request, error) {
md, ok := metadata.FromIncomingContext(ctx)
if md == nil || !ok {
return nil, yarpcerrors.Newf(yarpcerrors.CodeInternal, "cannot get metadata from ctx: %v", ctx)
}
transportRequest, err := metadataTo... | go | {
"resource": ""
} |
q10485 | TransportSpec | train | func TransportSpec(opts ...Option) yarpcconfig.TransportSpec {
var ts transportSpec
for _, o := range opts {
switch opt := o.(type) {
case TransportOption:
ts.transportOptions = append(ts.transportOptions, opt)
default:
panic(fmt.Sprintf("unknown option of type %T: %v", o, o))
}
}
return ts.Spec()
} | go | {
"resource": ""
} |
q10486 | BuildProcedures | train | func BuildProcedures(s Service, opts ...RegisterOption) []transport.Procedure {
var rc registerConfig
for _, opt := range opts {
opt.applyRegisterOption(&rc)
}
proto := protocol.Binary
if rc.Protocol != nil {
proto = rc.Protocol
}
svc := s.Name
if rc.ServiceName != "" {
svc = rc.ServiceName
}
rs := m... | go | {
"resource": ""
} |
q10487 | buildTransport | train | func buildTransport(cv *buildable, k *Kit) (transport.Transport, error) {
result, err := cv.Build(k)
if err != nil {
return nil, err
}
return result.(transport.Transport), nil
} | go | {
"resource": ""
} |
q10488 | buildInbound | train | func buildInbound(cv *buildable, t transport.Transport, k *Kit) (transport.Inbound, error) {
result, err := cv.Build(t, k)
if err != nil {
return nil, err
}
return result.(transport.Inbound), nil
} | go | {
"resource": ""
} |
q10489 | buildUnaryOutbound | train | func buildUnaryOutbound(o *buildableOutbound, t transport.Transport, k *Kit) (transport.UnaryOutbound, error) {
result, err := o.Value.Build(t, k.withTransportSpec(o.TransportSpec))
if err != nil {
return nil, err
}
return result.(transport.UnaryOutbound), nil
} | go | {
"resource": ""
} |
q10490 | buildOnewayOutbound | train | func buildOnewayOutbound(o *buildableOutbound, t transport.Transport, k *Kit) (transport.OnewayOutbound, error) {
result, err := o.Value.Build(t, k.withTransportSpec(o.TransportSpec))
if err != nil {
return nil, err
}
return result.(transport.OnewayOutbound), nil
} | go | {
"resource": ""
} |
q10491 | buildStreamOutbound | train | func buildStreamOutbound(o *buildableOutbound, t transport.Transport, k *Kit) (transport.StreamOutbound, error) {
result, err := o.Value.Build(t, k.withTransportSpec(o.TransportSpec))
if err != nil {
return nil, err
}
return result.(transport.StreamOutbound), nil
} | go | {
"resource": ""
} |
q10492 | New | train | func New(name string, transport peer.Transport, availableChooser peer.ListImplementation, opts ...ListOption) *List {
options := defaultListOptions
for _, o := range opts {
o.apply(&options)
}
return &List{
once: lifecycle.NewOnce(),
name: name,
uninitializedPeers: make(map[stri... | go | {
"resource": ""
} |
q10493 | EchoJSON | train | func EchoJSON(ctx context.Context, body map[string]interface{}) (map[string]interface{}, error) {
call := yarpc.CallFromContext(ctx)
for _, k := range call.HeaderNames() {
if err := call.WriteResponseHeader(k, call.Header(k)); err != nil {
return nil, err
}
}
return body, nil
} | go | {
"resource": ""
} |
q10494 | Echo | train | func (EchoThrift) Echo(ctx context.Context, ping *echo.Ping) (*echo.Pong, error) {
call := yarpc.CallFromContext(ctx)
for _, k := range call.HeaderNames() {
if err := call.WriteResponseHeader(k, call.Header(k)); err != nil {
return nil, err
}
}
return &echo.Pong{Boop: ping.Beep}, nil
} | go | {
"resource": ""
} |
q10495 | Echo | train | func (EchoProtobuf) Echo(_ context.Context, request *crossdockpb.Ping) (*crossdockpb.Pong, error) {
if request == nil {
return nil, nil
}
return &crossdockpb.Pong{Boop: request.Beep}, nil
} | go | {
"resource": ""
} |
q10496 | BackoffStrategy | train | func BackoffStrategy(backoffStrategy backoff.Strategy) TransportOption {
return func(transportOptions *transportOptions) {
transportOptions.backoffStrategy = backoffStrategy
}
} | go | {
"resource": ""
} |
q10497 | InboundCredentials | train | func InboundCredentials(creds credentials.TransportCredentials) InboundOption {
return func(inboundOptions *inboundOptions) {
inboundOptions.creds = creds
}
} | go | {
"resource": ""
} |
q10498 | NotifyStatusChanged | train | func (t *peerThunk) NotifyStatusChanged(pid peer.Identifier) {
t.list.notifyStatusChanged(pid)
s := t.Subscriber()
if s != nil {
s.NotifyStatusChanged(pid)
}
} | go | {
"resource": ""
} |
q10499 | SetSubscriber | train | func (t *peerThunk) SetSubscriber(s peer.Subscriber) {
t.lock.Lock()
t.subscriber = s
t.lock.Unlock()
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.