sink

Documentation

Index

• Variables
• type SinkClientMethods
• type SinkClientStub
  • func SinkClient(name string) SinkClientStub
• type SinkServerMethods
• type SinkServerStub
  • func SinkServer(impl SinkServerMethods) SinkServerStub
• type SinkServerStubMethods
• type SinkSinkStreamClientCall
• type SinkSinkStreamClientStream
• type SinkSinkStreamServerCall
• type SinkSinkStreamServerCallStub
  • func (s *SinkSinkStreamServerCallStub) Init(call rpc.StreamServerCall)
  • func (s *SinkSinkStreamServerCallStub) RecvStream() interface{ ... }
• type SinkSinkStreamServerStream

Variables

var SinkDesc rpc.InterfaceDesc = descSink

SinkDesc describes the Sink interface.

Types

type SinkClientMethods

type SinkClientMethods interface {
	// Sync always returns nil.
	Sink(_ *context.T, Payload []byte, _ ...rpc.CallOpt) error
	// SyncStream always returns nil.
	SinkStream(*context.T, ...rpc.CallOpt) (SinkSinkStreamClientCall, error)
}

SinkClientMethods is the client interface containing Sink methods.

type SinkClientStub

type SinkClientStub interface {
	SinkClientMethods
	rpc.UniversalServiceMethods
}

SinkClientStub adds universal methods to SinkClientMethods.

func SinkClient

func SinkClient(name string) SinkClientStub

SinkClient returns a client stub for Sink.

type SinkServerMethods

type SinkServerMethods interface {
	// Sync always returns nil.
	Sink(_ *context.T, _ rpc.ServerCall, Payload []byte) error
	// SyncStream always returns nil.
	SinkStream(*context.T, SinkSinkStreamServerCall) error
}

SinkServerMethods is the interface a server writer implements for Sink.

type SinkServerStub

type SinkServerStub interface {
	SinkServerStubMethods
	// Describe the Sink interfaces.
	Describe__() []rpc.InterfaceDesc
}

SinkServerStub adds universal methods to SinkServerStubMethods.

func SinkServer

func SinkServer(impl SinkServerMethods) SinkServerStub

SinkServer returns a server stub for Sink. It converts an implementation of SinkServerMethods into an object that may be used by rpc.Server.

type SinkServerStubMethods

type SinkServerStubMethods interface {
	// Sync always returns nil.
	Sink(_ *context.T, _ rpc.ServerCall, Payload []byte) error
	// SyncStream always returns nil.
	SinkStream(*context.T, *SinkSinkStreamServerCallStub) error
}

SinkServerStubMethods is the server interface containing Sink methods, as expected by rpc.Server. The only difference between this interface and SinkServerMethods is the streaming methods.

type SinkSinkStreamClientCall

type SinkSinkStreamClientCall interface {
	SinkSinkStreamClientStream
	// Finish performs the equivalent of SendStream().Close, then blocks until
	// the server is done, and returns the positional return values for the call.
	//
	// Finish returns immediately if the call has been canceled; depending on the
	// timing the output could either be an error signaling cancelation, or the
	// valid positional return values from the server.
	//
	// Calling Finish is mandatory for releasing stream resources, unless the call
	// has been canceled or any of the other methods return an error.  Finish should
	// be called at most once.
	Finish() error
}

SinkSinkStreamClientCall represents the call returned from Sink.SinkStream.

type SinkSinkStreamClientStream

type SinkSinkStreamClientStream interface {
	// SendStream returns the send side of the Sink.SinkStream client stream.
	SendStream() interface {
		// Send places the item onto the output stream.  Returns errors
		// encountered while sending, or if Send is called after Close or
		// the stream has been canceled.  Blocks if there is no buffer
		// space; will unblock when buffer space is available or after
		// the stream has been canceled.
		Send(item []byte) error
		// Close indicates to the server that no more items will be sent;
		// server Recv calls will receive io.EOF after all sent items.
		// This is an optional call - e.g. a client might call Close if it
		// needs to continue receiving items from the server after it's
		// done sending.  Returns errors encountered while closing, or if
		// Close is called after the stream has been canceled.  Like Send,
		// blocks if there is no buffer space available.
		Close() error
	}
}

SinkSinkStreamClientStream is the client stream for Sink.SinkStream.

type SinkSinkStreamServerCall

type SinkSinkStreamServerCall interface {
	rpc.ServerCall
	SinkSinkStreamServerStream
}

SinkSinkStreamServerCall represents the context passed to Sink.SinkStream.

type SinkSinkStreamServerCallStub

type SinkSinkStreamServerCallStub struct {
	rpc.StreamServerCall
	// contains filtered or unexported fields
}

SinkSinkStreamServerCallStub is a wrapper that converts rpc.StreamServerCall into a typesafe stub that implements SinkSinkStreamServerCall.

func (*SinkSinkStreamServerCallStub) Init

func (s *SinkSinkStreamServerCallStub) Init(call rpc.StreamServerCall)

Init initializes SinkSinkStreamServerCallStub from rpc.StreamServerCall.

func (*SinkSinkStreamServerCallStub) RecvStream

func (s *SinkSinkStreamServerCallStub) RecvStream() interface {
	Advance() bool
	Value() []byte
	Err() error
}

RecvStream returns the receiver side of the Sink.SinkStream server stream.

type SinkSinkStreamServerStream

type SinkSinkStreamServerStream interface {
	// RecvStream returns the receiver side of the Sink.SinkStream server stream.
	RecvStream() interface {
		// Advance stages an item so that it may be retrieved via Value.  Returns
		// true iff there is an item to retrieve.  Advance must be called before
		// Value is called.  May block if an item is not available.
		Advance() bool
		// Value returns the item that was staged by Advance.  May panic if Advance
		// returned false or was not called.  Never blocks.
		Value() []byte
		// Err returns any error encountered by Advance.  Never blocks.
		Err() error
	}
}

SinkSinkStreamServerStream is the server stream for Sink.SinkStream.