_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: port,
}, nil)
}
return l, nil
} | 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.ContextID)
}
return fmt.Sprintf("%s:%d", host, a.Port)
} | 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 could make use of xerr.Op here, we're passing it manually
// for consistency, since some of the Conn calls we are making don't
// wrap an os.File, which would return an Op for us.
//
// As a special case, if the error is related to access to the /dev/vsock
// device, we don't unwrap it, so the caller has more context as to why
// their operation actually failed than "permission denied" or similar.
if xerr.Path != devVsock {
err = xerr.Err
}
}
switch {
case err == io.EOF, isErrno(err, enotconn):
// We may see a literal io.EOF as happens with x/net/nettest, but
// "transport not connected" also means io.EOF in Go.
return io.EOF
case err == os.ErrClosed, isErrno(err, ebadf), strings.Contains(err.Error(), "use of closed"):
// Different operations may return different errors that all effectively
// indicate a closed file.
//
// To rectify the differences, net.TCPConn uses an error with this text
// from internal/poll for the backing file already being closed.
err = errors.New("use of closed network connection")
default:
// Nothing to do, return this directly.
}
// Determine source and addr using the rules defined by net.OpError's
// documentation: https://golang.org/pkg/net/#OpError.
var source, addr net.Addr
switch op {
case opClose, opDial, opRawRead, opRawWrite, opRead, opWrite:
if local != nil {
source = local
}
if remote != nil {
addr = remote
}
case opAccept, opListen, opRawControl, opSet, opSyscallConn:
if local != nil {
addr = local
}
}
return &net.OpError{
Op: op,
Net: network,
Source: source,
Addr: addr,
Err: err,
}
} | 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.
if port == 0 {
port = unix.VMADDR_PORT_ANY
}
sa := &unix.SockaddrVM{
CID: cid,
Port: port,
}
if err := lfd.Bind(sa); err != nil {
return nil, err
}
if err := lfd.Listen(unix.SOMAXCONN); err != nil {
return nil, err
}
lsa, err := lfd.Getsockname()
if err != nil {
return nil, err
}
// Done with blocking mode setup, transition to non-blocking before the
// caller has a chance to start calling things concurrently that might make
// the locking situation tricky.
//
// Note: if any calls fail after this point, lfd.Close should be invoked
// for cleanup because the socket is now non-blocking.
if err := lfd.SetNonblocking("vsock-listen"); err != nil {
return nil, err
}
lsavm := lsa.(*unix.SockaddrVM)
addr := &Addr{
ContextID: lsavm.CID,
Port: lsavm.Port,
}
return &Listener{
l: &listener{
fd: lfd,
addr: addr,
},
}, nil
} | 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 cfd, sa, nil
} | 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: local,
remote: remote,
}, nil
} | 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.Connect(rsa); err != nil {
return nil, err
}
lsa, err := cfd.Getsockname()
if err != nil {
return nil, err
}
lsavm := lsa.(*unix.SockaddrVM)
local := &Addr{
ContextID: lsavm.CID,
Port: lsavm.Port,
}
remote := &Addr{
ContextID: cid,
Port: port,
}
return newConn(cfd, local, remote)
} | 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 stdout or a file to be created.
var w io.Writer
switch target {
case "":
logf("empty target, file will be written to stdout")
w = os.Stdout
default:
logf("creating file %q for output", target)
f, err := os.Create(target)
if err != nil {
fatalf("failed to create output file: %q", err)
}
defer f.Close()
w = f
}
// Optionally compute a checksum of the data.
var h hash.Hash
if checksum {
h = sha256.New()
w = io.MultiWriter(w, h)
}
logf("opening listener: %d", port)
l, err := vsock.Listen(port)
if err != nil {
fatalf("failed to listen: %v", err)
}
defer l.Close()
// Show server's address for setting up client flags.
log.Printf("receive: listening: %s", l.Addr())
// Accept a single connection, and receive stream from that connection.
c, err := vsutil.Accept(l, timeout)
if err != nil {
fatalf("failed to accept: %v", err)
}
_ = l.Close()
defer c.Close()
if timeout != 0 {
if err := c.SetDeadline(time.Now().Add(timeout)); err != nil {
fatalf("failed to set timeout: %v", err)
}
}
logf("server: %s", c.LocalAddr())
logf("client: %s", c.RemoteAddr())
logf("receiving data")
if _, err := io.Copy(w, c); err != nil {
fatalf("failed to receive data: %v", err)
}
logf("transfer complete")
if h != nil {
log.Printf("sha256 checksum: %x", h.Sum(nil))
}
} | 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 in.
var r io.Reader
switch target {
case "", "-":
logf("empty or stdin target, file will be read from stdin")
r = os.Stdin
default:
logf("opening file %q for input", target)
f, err := os.Open(target)
if err != nil {
fatalf("failed to open input file: %q", err)
}
defer f.Close()
r = f
}
// Optionally compute a checksum of the data.
var h hash.Hash
if checksum {
h = sha256.New()
r = io.TeeReader(r, h)
}
logf("dialing: %d.%d", cid, port)
// Dial a remote server and send a stream to that server.
c, err := vsock.Dial(cid, port)
if err != nil {
fatalf("failed to dial: %v", err)
}
defer c.Close()
logf("client: %s", c.LocalAddr())
logf("server: %s", c.RemoteAddr())
logf("sending data")
if _, err := io.Copy(c, r); err != nil {
fatalf("failed to send data: %v", err)
}
logf("transfer complete")
if h != nil {
log.Printf("sha256 checksum: %x", h.Sum(nil))
}
} | 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(availablePeers)
unavailablePeers := pl.removeAllUnavailablePeers(pl.unavailablePeers)
errs = pl.releaseAll(errs, unavailablePeers)
pl.addToUninitialized(unavailablePeers)
pl.shouldRetainPeers.Store(false)
return errs
} | 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.availableChooser.Choose(ctx, req)
pl.lock.Unlock()
if p != nil {
// A nil peer is an indication that there are no more peers
// available for pending choices.
// A non-nil peer indicates that we have drained the waiting
// channel but there may be other peer lists waiting for a peer.
// We re-fill the channel enabling those choices to proceed
// concurrently.
t := p.(*peerThunk)
pl.notifyPeerAvailable()
t.StartRequest()
return t.peer, t.boundOnFinish, nil
}
if err := pl.waitForPeerAddedEvent(ctx); err != nil {
return nil, nil, err
}
}
} | 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
_ = pl.handleUnavailablePeerStatusChange(t)
}
// No action required
} | 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, len(pl.unavailablePeers))
for _, t := range pl.unavailablePeers {
unavailables = append(unavailables, t.peer)
}
pl.lock.Unlock()
peersStatus := make([]introspection.PeerStatus, 0,
len(availables)+len(unavailables))
buildPeerStatus := func(peer peer.Peer) introspection.PeerStatus {
ps := peer.Status()
return introspection.PeerStatus{
Identifier: peer.Identifier(),
State: fmt.Sprintf("%s, %d pending request(s)",
ps.ConnectionStatus.String(),
ps.PendingRequestCount),
}
}
for _, peer := range availables {
peersStatus = append(peersStatus, buildPeerStatus(peer))
}
for _, peer := range unavailables {
peersStatus = append(peersStatus, buildPeerStatus(peer))
}
return introspection.ChooserStatus{
Name: "Single",
State: fmt.Sprintf("%s (%d/%d available)", state, len(availables),
len(availables)+len(unavailables)),
Peers: peersStatus,
}
} | 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.Sprintf("KeyValue_GetValue_Result{%v}", strings.Join(fields[:i], ", "))
} | 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.DoesNotExist != nil && v.DoesNotExist.Equals(rhs.DoesNotExist))) {
return false
}
return true
} | 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 {
procedures = append(procedures, examplepb.BuildKeyValueYARPCProcedures(keyValueYARPCServer)...)
}
if sinkYARPCServer != nil {
procedures = append(procedures, examplepb.BuildSinkYARPCProcedures(sinkYARPCServer)...)
}
if fooYARPCServer != nil {
procedures = append(procedures, examplepb.BuildFooYARPCProcedures(fooYARPCServer)...)
}
return testutils.WithClientInfo(
"example",
procedures,
transportType,
logger,
func(clientInfo *testutils.ClientInfo) error {
return f(
&Clients{
examplepb.NewKeyValueYARPCClient(clientInfo.ClientConfig),
examplepb.NewSinkYARPCClient(clientInfo.ClientConfig),
examplepb.NewFooYARPCClient(clientInfo.ClientConfig),
examplepb.NewKeyValueYARPCClient(clientInfo.ClientConfig, protobuf.UseJSON),
examplepb.NewSinkYARPCClient(clientInfo.ClientConfig, protobuf.UseJSON),
examplepb.NewFooYARPCClient(clientInfo.ClientConfig, protobuf.UseJSON),
examplepb.NewKeyValueClient(clientInfo.GRPCClientConn),
examplepb.NewSinkClient(clientInfo.GRPCClientConn),
examplepb.NewFooClient(clientInfo.GRPCClientConn),
clientInfo.ContextWrapper,
},
)
},
)
} | 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: ch, ServerHostPort: serverHostPort}
switch encoding {
case "raw":
runRaw(t, call)
case "json":
runJSON(t, call)
case "thrift":
runThrift(t, call)
default:
fatals.Fail("", "unknown encoding %q", encoding)
}
} | 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.graph.appErrLevel = *lvl
}
return m
} | 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.isApplicationError)
wrappedWriter.free()
return err
} | 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.ApplicationError
}
call.EndWithAppError(err, isApplicationError)
return res, err
} | 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.ServerStream?
call.End(err)
return err
} | 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 the *transport.ClientStream?
call.End(err)
return clientStream, err
} | 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,
// Protocol: protocol.Binary,
// }, opts...)
// return &MyServiceClient{client: c}
// }
//
// So Config is really the internal config as far as consumers of the
// generated client are concerned.
var cc clientConfig
for _, opt := range opts {
opt.applyClientOption(&cc)
}
p := protocol.Binary
if cc.Protocol != nil {
p = cc.Protocol
}
svc := c.Service
if cc.ServiceName != "" {
svc = cc.ServiceName
}
if cc.Multiplexed {
p = multiplexedOutboundProtocol{
Protocol: p,
Service: svc,
}
}
return thriftClient{
p: p,
cc: c.ClientConfig,
thriftService: svc,
Enveloping: cc.Enveloping,
}
} | 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 req.Encoding == "" {
missingParams = append(missingParams, "encoding")
}
if len(missingParams) > 0 {
return yarpcerrors.Newf(yarpcerrors.CodeInvalidArgument, "missing %s", strings.Join(missingParams, ", "))
}
return nil
} | 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,
RoutingKey: r.RoutingKey,
RoutingDelegate: r.RoutingDelegate,
}
} | 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 := server.ListenAndServe(); err != nil {
log.Fatalf("failed to start HTTP server: %v", 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 := metadataToTransportRequest(md)
if err != nil {
return nil, err
}
transportRequest.Transport = transportName
procedure, err := procedureFromStreamMethod(streamMethod)
if err != nil {
return nil, err
}
transportRequest.Procedure = procedure
if err := transport.ValidateRequest(transportRequest); err != nil {
return nil, err
}
return transportRequest, nil
} | 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 := make([]transport.Procedure, 0, len(s.Methods))
for _, method := range s.Methods {
var spec transport.HandlerSpec
switch method.HandlerSpec.Type {
case transport.Unary:
spec = transport.NewUnaryHandlerSpec(thriftUnaryHandler{
UnaryHandler: method.HandlerSpec.Unary,
Protocol: proto,
Enveloping: rc.Enveloping,
})
case transport.Oneway:
spec = transport.NewOnewayHandlerSpec(thriftOnewayHandler{
OnewayHandler: method.HandlerSpec.Oneway,
Protocol: proto,
Enveloping: rc.Enveloping,
})
default:
panic(fmt.Sprintf("Invalid handler type for %T", method))
}
rs = append(rs, transport.Procedure{
Name: procedure.ToName(svc, method.Name),
HandlerSpec: spec,
Encoding: Encoding,
Signature: method.Signature,
})
}
return rs
} | 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[string]peer.Identifier, options.capacity),
unavailablePeers: make(map[string]*peerThunk, options.capacity),
availablePeers: make(map[string]*peerThunk, options.capacity),
availableChooser: availableChooser,
transport: transport,
noShuffle: options.noShuffle,
randSrc: rand.NewSource(options.seed),
peerAvailableEvent: make(chan struct{}, 1),
}
} | 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.