benchmark

type BenchmarkClientMethods interface {
	// Echo returns the payload that it receives.
	Echo(_ *context.T, Payload []byte, _ ...rpc.CallOpt) ([]byte, error)
	// EchoStream returns the payload that it receives via the stream.
	EchoStream(*context.T, ...rpc.CallOpt) (BenchmarkEchoStreamClientCall, error)
}

type BenchmarkClientStub interface {
	BenchmarkClientMethods
	rpc.UniversalServiceMethods
}

type BenchmarkEchoStreamClientCall interface {
	BenchmarkEchoStreamClientStream
	// 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
}

type BenchmarkEchoStreamClientStream interface {
	// RecvStream returns the receiver side of the Benchmark.EchoStream client 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
	}
	// SendStream returns the send side of the Benchmark.EchoStream 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
	}
}

type BenchmarkEchoStreamServerCall interface {
	rpc.ServerCall
	BenchmarkEchoStreamServerStream
}

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

type BenchmarkEchoStreamServerStream interface {
	// RecvStream returns the receiver side of the Benchmark.EchoStream 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
	}
	// SendStream returns the send side of the Benchmark.EchoStream server stream.
	SendStream() interface {
		// Send places the item onto the output stream.  Returns errors encountered
		// while sending.  Blocks if there is no buffer space; will unblock when
		// buffer space is available.
		Send(item []byte) error
	}
}

type BenchmarkServerMethods interface {
	// Echo returns the payload that it receives.
	Echo(_ *context.T, _ rpc.ServerCall, Payload []byte) ([]byte, error)
	// EchoStream returns the payload that it receives via the stream.
	EchoStream(*context.T, BenchmarkEchoStreamServerCall) error
}

type BenchmarkServerStub interface {
	BenchmarkServerStubMethods
	// Describe the Benchmark interfaces.
	Describe__() []rpc.InterfaceDesc
}

type BenchmarkServerStubMethods interface {
	// Echo returns the payload that it receives.
	Echo(_ *context.T, _ rpc.ServerCall, Payload []byte) ([]byte, error)
	// EchoStream returns the payload that it receives via the stream.
	EchoStream(*context.T, *BenchmarkEchoStreamServerCallStub) error
}

type Caveat struct {
	Id               []byte `protobuf:"bytes,1,req,name=id" json:"id,omitempty"`
	ParamVom         []byte `protobuf:"bytes,2,req,name=paramVom" json:"paramVom,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

type Certificate struct {
	Extension        *string    `protobuf:"bytes,1,req,name=extension" json:"extension,omitempty"`
	PublicKey        []byte     `protobuf:"bytes,2,req,name=publicKey" json:"publicKey,omitempty"`
	Caveats          []*Caveat  `protobuf:"bytes,3,rep,name=caveats" json:"caveats,omitempty"`
	Signature        *Signature `protobuf:"bytes,4,req,name=signature" json:"signature,omitempty"`
	XXX_unrecognized []byte     `json:"-"`
}

type CertificateChain struct {
	Certificates     []*Certificate `protobuf:"bytes,1,rep,name=certificates" json:"certificates,omitempty"`
	XXX_unrecognized []byte         `json:"-"`
}

type RpcRequest struct {
	Suffix           *string                `protobuf:"bytes,1,req,name=suffix" json:"suffix,omitempty"`
	Method           *string                `protobuf:"bytes,2,req,name=method" json:"method,omitempty"`
	NumPosArgs       *uint64                `protobuf:"varint,3,req,name=numPosArgs" json:"numPosArgs,omitempty"`
	EndStreamArgs    *bool                  `protobuf:"varint,4,req,name=endStreamArgs" json:"endStreamArgs,omitempty"`
	Deadline         *TimeWireDeadline      `protobuf:"bytes,5,req,name=deadline" json:"deadline,omitempty"`
	GrantedBlessings *SecurityWireBlessings `protobuf:"bytes,6,req,name=grantedBlessings" json:"grantedBlessings,omitempty"`
	TraceRequest     *VtraceRequest         `protobuf:"bytes,7,req,name=traceRequest" json:"traceRequest,omitempty"`
	Language         *string                `protobuf:"bytes,8,req,name=language" json:"language,omitempty"`
	XXX_unrecognized []byte                 `json:"-"`
}

type RpcResponse struct {
	Error            *string         `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
	EndStreamResults *bool           `protobuf:"varint,2,req,name=endStreamResults" json:"endStreamResults,omitempty"`
	NumPosResults    *uint64         `protobuf:"varint,3,req,name=numPosResults" json:"numPosResults,omitempty"`
	TraceResponse    *VtraceResponse `protobuf:"bytes,4,req,name=traceResponse" json:"traceResponse,omitempty"`
	AckBlessings     *bool           `protobuf:"varint,5,req,name=ackBlessings" json:"ackBlessings,omitempty"`
	XXX_unrecognized []byte          `json:"-"`
}

type SecurityWireBlessings struct {
	CertificateChains []*CertificateChain `protobuf:"bytes,1,rep,name=certificateChains" json:"certificateChains,omitempty"`
	XXX_unrecognized  []byte              `json:"-"`
}

type Signature struct {
	Purpose          []byte  `protobuf:"bytes,1,req,name=purpose" json:"purpose,omitempty"`
	Hash             *string `protobuf:"bytes,2,req,name=hash" json:"hash,omitempty"`
	R                []byte  `protobuf:"bytes,3,req,name=r" json:"r,omitempty"`
	S                []byte  `protobuf:"bytes,4,req,name=s" json:"s,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

type TimeDuration struct {
	Seconds          *int64 `protobuf:"varint,1,req,name=seconds" json:"seconds,omitempty"`
	Nanos            *int64 `protobuf:"varint,2,req,name=nanos" json:"nanos,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

type TimeTime struct {
	Seconds          *int64 `protobuf:"varint,1,req,name=seconds" json:"seconds,omitempty"`
	Nanos            *int32 `protobuf:"varint,2,req,name=nanos" json:"nanos,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

type TimeWireDeadline struct {
	FromNow          *TimeDuration `protobuf:"bytes,1,req,name=fromNow" json:"fromNow,omitempty"`
	NoDeadline       *bool         `protobuf:"varint,2,req,name=noDeadline" json:"noDeadline,omitempty"`
	XXX_unrecognized []byte        `json:"-"`
}

type VtraceAnnotation struct {
	When             *TimeTime `protobuf:"bytes,1,req,name=when" json:"when,omitempty"`
	Msg              *string   `protobuf:"bytes,2,req,name=msg" json:"msg,omitempty"`
	XXX_unrecognized []byte    `json:"-"`
}

type VtraceRequest struct {
	SpanId           []byte `protobuf:"bytes,1,req,name=spanId" json:"spanId,omitempty"`
	TraceId          []byte `protobuf:"bytes,2,req,name=traceId" json:"traceId,omitempty"`
	Flags            *int32 `protobuf:"varint,3,req,name=flags" json:"flags,omitempty"`
	LogLevel         *int32 `protobuf:"varint,4,req,name=logLevel" json:"logLevel,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

type VtraceResponse struct {
	TraceFlags       *int32             `protobuf:"varint,1,req,name=traceFlags" json:"traceFlags,omitempty"`
	Trace            *VtraceTraceRecord `protobuf:"bytes,2,req,name=trace" json:"trace,omitempty"`
	XXX_unrecognized []byte             `json:"-"`
}

type VtraceSpanRecord struct {
	Id               []byte              `protobuf:"bytes,1,req,name=id" json:"id,omitempty"`
	Parent           []byte              `protobuf:"bytes,2,req,name=parent" json:"parent,omitempty"`
	Name             *string             `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
	Start            *TimeTime           `protobuf:"bytes,4,req,name=start" json:"start,omitempty"`
	End              *TimeTime           `protobuf:"bytes,5,req,name=end" json:"end,omitempty"`
	Annotations      []*VtraceAnnotation `protobuf:"bytes,6,rep,name=annotations" json:"annotations,omitempty"`
	XXX_unrecognized []byte              `json:"-"`
}

type VtraceTraceRecord struct {
	Id               []byte              `protobuf:"bytes,1,req,name=id" json:"id,omitempty"`
	SpanRecord       []*VtraceSpanRecord `protobuf:"bytes,2,rep,name=spanRecord" json:"spanRecord,omitempty"`
	XXX_unrecognized []byte              `json:"-"`
}