poanetwork
/
gecko
mirror of https://github.com/poanetwork/gecko.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into vms-avm-service-test

This commit is contained in:
Stephen Buttolph 2020-04-17 02:51:01 -04:00 committed by GitHub
parent 5797347e6a adebf8bb80
commit be90dc71be
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
29 changed files with 3902 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
networking/handshake_handlers.go
View File

@ -79,7 +79,7 @@ const (
GetVersionTimeout = 2 * time.Second
// ReconnectTimeout is the amount of time to wait to reconnect to a staker
// before giving up
ReconnectTimeout = 1 * time.Minute
ReconnectTimeout = 10 * time.Minute
)
// Manager is the struct that will be accessed on event calls

5
node/node.go
View File

@ -152,9 +152,10 @@ func (n *Node) initNetlib() error {
// Create peer network config, may have tls enabled
peerConfig := salticidae.NewPeerNetworkConfig()
msgConfig := peerConfig.AsMsgNetworkConfig()
msgConfig.MaxMsgSize(maxMessageSize)
if n.Config.EnableStaking {
msgConfig := peerConfig.AsMsgNetworkConfig()
msgConfig.MaxMsgSize(maxMessageSize)
msgConfig.EnableTLS(true)
msgConfig.TLSKeyFile(n.Config.StakingKeyFile)
msgConfig.TLSCertFile(n.Config.StakingCertFile)

118
vms/rpcchainvm/ghttp/gconn/conn_client.go Normal file
View File

@ -0,0 +1,118 @@
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package gconn
import (
"context"
"errors"
"io"
"net"
"time"
"github.com/ava-labs/gecko/utils/wrappers"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gconn/proto"
)
// Client is an implementation of a messenger channel that talks over RPC.
type Client struct {
client proto.ConnClient
local net.Addr
remote net.Addr
toClose []io.Closer
}
// NewClient returns a database instance connected to a remote database instance
func NewClient(client proto.ConnClient, local, remote net.Addr, toClose ...io.Closer) *Client {
return &Client{
client: client,
local: local,
remote: remote,
toClose: toClose,
}
}
// Read ...
func (c *Client) Read(p []byte) (int, error) {
resp, err := c.client.Read(context.Background(), &proto.ReadRequest{
Length: int32(len(p)),
})
if err != nil {
return 0, err
}
copy(p, resp.Read)
if resp.Errored {
err = errors.New(resp.Error)
}
return len(resp.Read), err
}
// Write ...
func (c *Client) Write(b []byte) (int, error) {
resp, err := c.client.Write(context.Background(), &proto.WriteRequest{
Payload: b,
})
if err != nil {
return 0, err
}
if resp.Errored {
err = errors.New(resp.Error)
}
return int(resp.Length), err
}
// Close ...
func (c *Client) Close() error {
_, err := c.client.Close(context.Background(), &proto.CloseRequest{})
errs := wrappers.Errs{}
errs.Add(err)
for _, toClose := range c.toClose {
errs.Add(toClose.Close())
}
return errs.Err
}
// LocalAddr ...
func (c *Client) LocalAddr() net.Addr { return c.local }
// RemoteAddr ...
func (c *Client) RemoteAddr() net.Addr { return c.remote }
// SetDeadline ...
func (c *Client) SetDeadline(t time.Time) error {
bytes, err := t.MarshalBinary()
if err != nil {
return err
}
_, err = c.client.SetDeadline(context.Background(), &proto.SetDeadlineRequest{
Time: bytes,
})
return err
}
// SetReadDeadline ...
func (c *Client) SetReadDeadline(t time.Time) error {
bytes, err := t.MarshalBinary()
if err != nil {
return err
}
_, err = c.client.SetReadDeadline(context.Background(), &proto.SetReadDeadlineRequest{
Time: bytes,
})
return err
}
// SetWriteDeadline ...
func (c *Client) SetWriteDeadline(t time.Time) error {
bytes, err := t.MarshalBinary()
if err != nil {
return err
}
_, err = c.client.SetWriteDeadline(context.Background(), &proto.SetWriteDeadlineRequest{
Time: bytes,
})
return err
}

80
vms/rpcchainvm/ghttp/gconn/conn_server.go Normal file
View File

@ -0,0 +1,80 @@
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package gconn
import (
"context"
"net"
"time"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gconn/proto"
)
// Server is a http.Handler that is managed over RPC.
type Server struct{ conn net.Conn }
// NewServer returns a http.Handler instance manage remotely
func NewServer(conn net.Conn) *Server {
return &Server{conn: conn}
}
// Read ...
func (s *Server) Read(ctx context.Context, req *proto.ReadRequest) (*proto.ReadResponse, error) {
buf := make([]byte, int(req.Length))
n, err := s.conn.Read(buf)
resp := &proto.ReadResponse{
Read: buf[:n],
}
if err != nil {
resp.Errored = true
resp.Error = err.Error()
}
return resp, nil
}
// Write ...
func (s *Server) Write(ctx context.Context, req *proto.WriteRequest) (*proto.WriteResponse, error) {
n, err := s.conn.Write(req.Payload)
if err != nil {
return nil, err
}
return &proto.WriteResponse{
Length: int32(n),
}, nil
}
// Close ...
func (s *Server) Close(ctx context.Context, req *proto.CloseRequest) (*proto.CloseResponse, error) {
return &proto.CloseResponse{}, s.conn.Close()
}
// SetDeadline ...
func (s *Server) SetDeadline(ctx context.Context, req *proto.SetDeadlineRequest) (*proto.SetDeadlineResponse, error) {
deadline := time.Time{}
err := deadline.UnmarshalBinary(req.Time)
if err != nil {
return nil, err
}
return &proto.SetDeadlineResponse{}, s.conn.SetDeadline(deadline)
}
// SetReadDeadline ...
func (s *Server) SetReadDeadline(ctx context.Context, req *proto.SetReadDeadlineRequest) (*proto.SetReadDeadlineResponse, error) {
deadline := time.Time{}
err := deadline.UnmarshalBinary(req.Time)
if err != nil {
return nil, err
}
return &proto.SetReadDeadlineResponse{}, s.conn.SetReadDeadline(deadline)
}
// SetWriteDeadline ...
func (s *Server) SetWriteDeadline(ctx context.Context, req *proto.SetWriteDeadlineRequest) (*proto.SetWriteDeadlineResponse, error) {
deadline := time.Time{}
err := deadline.UnmarshalBinary(req.Time)
if err != nil {
return nil, err
}
return &proto.SetWriteDeadlineResponse{}, s.conn.SetWriteDeadline(deadline)
}

788
vms/rpcchainvm/ghttp/gconn/proto/conn.pb.go Normal file
View File

@ -0,0 +1,788 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: conn.proto
package proto
import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type ReadRequest struct {
Length int32 `protobuf:"varint,1,opt,name=length,proto3" json:"length,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ReadRequest) Reset() { *m = ReadRequest{} }
func (m *ReadRequest) String() string { return proto.CompactTextString(m) }
func (*ReadRequest) ProtoMessage() {}
func (*ReadRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{0}
}
func (m *ReadRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReadRequest.Unmarshal(m, b)
}
func (m *ReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ReadRequest.Marshal(b, m, deterministic)
}
func (m *ReadRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ReadRequest.Merge(m, src)
}
func (m *ReadRequest) XXX_Size() int {
return xxx_messageInfo_ReadRequest.Size(m)
}
func (m *ReadRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ReadRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ReadRequest proto.InternalMessageInfo
func (m *ReadRequest) GetLength() int32 {
if m != nil {
return m.Length
}
return 0
}
type ReadResponse struct {
Read []byte `protobuf:"bytes,1,opt,name=read,proto3" json:"read,omitempty"`
Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
Errored bool `protobuf:"varint,3,opt,name=errored,proto3" json:"errored,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ReadResponse) Reset() { *m = ReadResponse{} }
func (m *ReadResponse) String() string { return proto.CompactTextString(m) }
func (*ReadResponse) ProtoMessage() {}
func (*ReadResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{1}
}
func (m *ReadResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReadResponse.Unmarshal(m, b)
}
func (m *ReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ReadResponse.Marshal(b, m, deterministic)
}
func (m *ReadResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ReadResponse.Merge(m, src)
}
func (m *ReadResponse) XXX_Size() int {
return xxx_messageInfo_ReadResponse.Size(m)
}
func (m *ReadResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ReadResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ReadResponse proto.InternalMessageInfo
func (m *ReadResponse) GetRead() []byte {
if m != nil {
return m.Read
}
return nil
}
func (m *ReadResponse) GetError() string {
if m != nil {
return m.Error
}
return ""
}
func (m *ReadResponse) GetErrored() bool {
if m != nil {
return m.Errored
}
return false
}
type WriteRequest struct {
Payload []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WriteRequest) Reset() { *m = WriteRequest{} }
func (m *WriteRequest) String() string { return proto.CompactTextString(m) }
func (*WriteRequest) ProtoMessage() {}
func (*WriteRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{2}
}
func (m *WriteRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_WriteRequest.Unmarshal(m, b)
}
func (m *WriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WriteRequest.Marshal(b, m, deterministic)
}
func (m *WriteRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_WriteRequest.Merge(m, src)
}
func (m *WriteRequest) XXX_Size() int {
return xxx_messageInfo_WriteRequest.Size(m)
}
func (m *WriteRequest) XXX_DiscardUnknown() {
xxx_messageInfo_WriteRequest.DiscardUnknown(m)
}
var xxx_messageInfo_WriteRequest proto.InternalMessageInfo
func (m *WriteRequest) GetPayload() []byte {
if m != nil {
return m.Payload
}
return nil
}
type WriteResponse struct {
Length int32 `protobuf:"varint,1,opt,name=length,proto3" json:"length,omitempty"`
Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
Errored bool `protobuf:"varint,3,opt,name=errored,proto3" json:"errored,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WriteResponse) Reset() { *m = WriteResponse{} }
func (m *WriteResponse) String() string { return proto.CompactTextString(m) }
func (*WriteResponse) ProtoMessage() {}
func (*WriteResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{3}
}
func (m *WriteResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_WriteResponse.Unmarshal(m, b)
}
func (m *WriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WriteResponse.Marshal(b, m, deterministic)
}
func (m *WriteResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_WriteResponse.Merge(m, src)
}
func (m *WriteResponse) XXX_Size() int {
return xxx_messageInfo_WriteResponse.Size(m)
}
func (m *WriteResponse) XXX_DiscardUnknown() {
xxx_messageInfo_WriteResponse.DiscardUnknown(m)
}
var xxx_messageInfo_WriteResponse proto.InternalMessageInfo
func (m *WriteResponse) GetLength() int32 {
if m != nil {
return m.Length
}
return 0
}
func (m *WriteResponse) GetError() string {
if m != nil {
return m.Error
}
return ""
}
func (m *WriteResponse) GetErrored() bool {
if m != nil {
return m.Errored
}
return false
}
type CloseRequest struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CloseRequest) Reset() { *m = CloseRequest{} }
func (m *CloseRequest) String() string { return proto.CompactTextString(m) }
func (*CloseRequest) ProtoMessage() {}
func (*CloseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{4}
}
func (m *CloseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CloseRequest.Unmarshal(m, b)
}
func (m *CloseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CloseRequest.Marshal(b, m, deterministic)
}
func (m *CloseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CloseRequest.Merge(m, src)
}
func (m *CloseRequest) XXX_Size() int {
return xxx_messageInfo_CloseRequest.Size(m)
}
func (m *CloseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CloseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CloseRequest proto.InternalMessageInfo
type CloseResponse struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CloseResponse) Reset() { *m = CloseResponse{} }
func (m *CloseResponse) String() string { return proto.CompactTextString(m) }
func (*CloseResponse) ProtoMessage() {}
func (*CloseResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{5}
}
func (m *CloseResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CloseResponse.Unmarshal(m, b)
}
func (m *CloseResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CloseResponse.Marshal(b, m, deterministic)
}
func (m *CloseResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CloseResponse.Merge(m, src)
}
func (m *CloseResponse) XXX_Size() int {
return xxx_messageInfo_CloseResponse.Size(m)
}
func (m *CloseResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CloseResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CloseResponse proto.InternalMessageInfo
type SetDeadlineRequest struct {
Time []byte `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetDeadlineRequest) Reset() { *m = SetDeadlineRequest{} }
func (m *SetDeadlineRequest) String() string { return proto.CompactTextString(m) }
func (*SetDeadlineRequest) ProtoMessage() {}
func (*SetDeadlineRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{6}
}
func (m *SetDeadlineRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetDeadlineRequest.Unmarshal(m, b)
}
func (m *SetDeadlineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetDeadlineRequest.Marshal(b, m, deterministic)
}
func (m *SetDeadlineRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetDeadlineRequest.Merge(m, src)
}
func (m *SetDeadlineRequest) XXX_Size() int {
return xxx_messageInfo_SetDeadlineRequest.Size(m)
}
func (m *SetDeadlineRequest) XXX_DiscardUnknown() {
xxx_messageInfo_SetDeadlineRequest.DiscardUnknown(m)
}
var xxx_messageInfo_SetDeadlineRequest proto.InternalMessageInfo
func (m *SetDeadlineRequest) GetTime() []byte {
if m != nil {
return m.Time
}
return nil
}
type SetDeadlineResponse struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetDeadlineResponse) Reset() { *m = SetDeadlineResponse{} }
func (m *SetDeadlineResponse) String() string { return proto.CompactTextString(m) }
func (*SetDeadlineResponse) ProtoMessage() {}
func (*SetDeadlineResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{7}
}
func (m *SetDeadlineResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetDeadlineResponse.Unmarshal(m, b)
}
func (m *SetDeadlineResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetDeadlineResponse.Marshal(b, m, deterministic)
}
func (m *SetDeadlineResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetDeadlineResponse.Merge(m, src)
}
func (m *SetDeadlineResponse) XXX_Size() int {
return xxx_messageInfo_SetDeadlineResponse.Size(m)
}
func (m *SetDeadlineResponse) XXX_DiscardUnknown() {
xxx_messageInfo_SetDeadlineResponse.DiscardUnknown(m)
}
var xxx_messageInfo_SetDeadlineResponse proto.InternalMessageInfo
type SetReadDeadlineRequest struct {
Time []byte `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetReadDeadlineRequest) Reset() { *m = SetReadDeadlineRequest{} }
func (m *SetReadDeadlineRequest) String() string { return proto.CompactTextString(m) }
func (*SetReadDeadlineRequest) ProtoMessage() {}
func (*SetReadDeadlineRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{8}
}
func (m *SetReadDeadlineRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetReadDeadlineRequest.Unmarshal(m, b)
}
func (m *SetReadDeadlineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetReadDeadlineRequest.Marshal(b, m, deterministic)
}
func (m *SetReadDeadlineRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetReadDeadlineRequest.Merge(m, src)
}
func (m *SetReadDeadlineRequest) XXX_Size() int {
return xxx_messageInfo_SetReadDeadlineRequest.Size(m)
}
func (m *SetReadDeadlineRequest) XXX_DiscardUnknown() {
xxx_messageInfo_SetReadDeadlineRequest.DiscardUnknown(m)
}
var xxx_messageInfo_SetReadDeadlineRequest proto.InternalMessageInfo
func (m *SetReadDeadlineRequest) GetTime() []byte {
if m != nil {
return m.Time
}
return nil
}
type SetReadDeadlineResponse struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetReadDeadlineResponse) Reset() { *m = SetReadDeadlineResponse{} }
func (m *SetReadDeadlineResponse) String() string { return proto.CompactTextString(m) }
func (*SetReadDeadlineResponse) ProtoMessage() {}
func (*SetReadDeadlineResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{9}
}
func (m *SetReadDeadlineResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetReadDeadlineResponse.Unmarshal(m, b)
}
func (m *SetReadDeadlineResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetReadDeadlineResponse.Marshal(b, m, deterministic)
}
func (m *SetReadDeadlineResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetReadDeadlineResponse.Merge(m, src)
}
func (m *SetReadDeadlineResponse) XXX_Size() int {
return xxx_messageInfo_SetReadDeadlineResponse.Size(m)
}
func (m *SetReadDeadlineResponse) XXX_DiscardUnknown() {
xxx_messageInfo_SetReadDeadlineResponse.DiscardUnknown(m)
}
var xxx_messageInfo_SetReadDeadlineResponse proto.InternalMessageInfo
type SetWriteDeadlineRequest struct {
Time []byte `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetWriteDeadlineRequest) Reset() { *m = SetWriteDeadlineRequest{} }
func (m *SetWriteDeadlineRequest) String() string { return proto.CompactTextString(m) }
func (*SetWriteDeadlineRequest) ProtoMessage() {}
func (*SetWriteDeadlineRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{10}
}
func (m *SetWriteDeadlineRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetWriteDeadlineRequest.Unmarshal(m, b)
}
func (m *SetWriteDeadlineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetWriteDeadlineRequest.Marshal(b, m, deterministic)
}
func (m *SetWriteDeadlineRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetWriteDeadlineRequest.Merge(m, src)
}
func (m *SetWriteDeadlineRequest) XXX_Size() int {
return xxx_messageInfo_SetWriteDeadlineRequest.Size(m)
}
func (m *SetWriteDeadlineRequest) XXX_DiscardUnknown() {
xxx_messageInfo_SetWriteDeadlineRequest.DiscardUnknown(m)
}
var xxx_messageInfo_SetWriteDeadlineRequest proto.InternalMessageInfo
func (m *SetWriteDeadlineRequest) GetTime() []byte {
if m != nil {
return m.Time
}
return nil
}
type SetWriteDeadlineResponse struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetWriteDeadlineResponse) Reset() { *m = SetWriteDeadlineResponse{} }
func (m *SetWriteDeadlineResponse) String() string { return proto.CompactTextString(m) }
func (*SetWriteDeadlineResponse) ProtoMessage() {}
func (*SetWriteDeadlineResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_f401a58c1fc7ceef, []int{11}
}
func (m *SetWriteDeadlineResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetWriteDeadlineResponse.Unmarshal(m, b)
}
func (m *SetWriteDeadlineResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetWriteDeadlineResponse.Marshal(b, m, deterministic)
}
func (m *SetWriteDeadlineResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetWriteDeadlineResponse.Merge(m, src)
}
func (m *SetWriteDeadlineResponse) XXX_Size() int {
return xxx_messageInfo_SetWriteDeadlineResponse.Size(m)
}
func (m *SetWriteDeadlineResponse) XXX_DiscardUnknown() {
xxx_messageInfo_SetWriteDeadlineResponse.DiscardUnknown(m)
}
var xxx_messageInfo_SetWriteDeadlineResponse proto.InternalMessageInfo
func init() {
proto.RegisterType((*ReadRequest)(nil), "proto.ReadRequest")
proto.RegisterType((*ReadResponse)(nil), "proto.ReadResponse")
proto.RegisterType((*WriteRequest)(nil), "proto.WriteRequest")
proto.RegisterType((*WriteResponse)(nil), "proto.WriteResponse")
proto.RegisterType((*CloseRequest)(nil), "proto.CloseRequest")
proto.RegisterType((*CloseResponse)(nil), "proto.CloseResponse")
proto.RegisterType((*SetDeadlineRequest)(nil), "proto.SetDeadlineRequest")
proto.RegisterType((*SetDeadlineResponse)(nil), "proto.SetDeadlineResponse")
proto.RegisterType((*SetReadDeadlineRequest)(nil), "proto.SetReadDeadlineRequest")
proto.RegisterType((*SetReadDeadlineResponse)(nil), "proto.SetReadDeadlineResponse")
proto.RegisterType((*SetWriteDeadlineRequest)(nil), "proto.SetWriteDeadlineRequest")
proto.RegisterType((*SetWriteDeadlineResponse)(nil), "proto.SetWriteDeadlineResponse")
}
func init() { proto.RegisterFile("conn.proto", fileDescriptor_f401a58c1fc7ceef) }
var fileDescriptor_f401a58c1fc7ceef = []byte{
// 351 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x52, 0xd1, 0x4e, 0xea, 0x40,
0x10, 0x4d, 0x2f, 0x2d, 0x5c, 0x87, 0x22, 0x66, 0x40, 0x2c, 0x9b, 0xa8, 0x64, 0x13, 0x93, 0x3e,
0x28, 0x26, 0xf8, 0x09, 0xf0, 0x01, 0x66, 0x79, 0xe0, 0xb9, 0xda, 0x89, 0x92, 0xd4, 0x5d, 0x6c,
0xd7, 0x07, 0xff, 0xc1, 0x8f, 0x36, 0x6c, 0xb7, 0xa5, 0x05, 0x9a, 0xe0, 0x53, 0xf7, 0xec, 0x39,
0x73, 0x66, 0x7a, 0x66, 0x01, 0x5e, 0x95, 0x94, 0xd3, 0x4d, 0xaa, 0xb4, 0x42, 0xcf, 0x7c, 0xf8,
0x1d, 0x74, 0x05, 0x45, 0xb1, 0xa0, 0xcf, 0x2f, 0xca, 0x34, 0x8e, 0xa0, 0x9d, 0x90, 0x7c, 0xd3,
0xef, 0x81, 0x33, 0x71, 0x42, 0x4f, 0x58, 0xc4, 0x05, 0xf8, 0xb9, 0x2c, 0xdb, 0x28, 0x99, 0x11,
0x22, 0xb8, 0x29, 0x45, 0xb1, 0x51, 0xf9, 0xc2, 0x9c, 0x71, 0x08, 0x1e, 0xa5, 0xa9, 0x4a, 0x83,
0x7f, 0x13, 0x27, 0x3c, 0x13, 0x39, 0xc0, 0x00, 0x3a, 0xe6, 0x40, 0x71, 0xd0, 0x9a, 0x38, 0xe1,
0x7f, 0x51, 0x40, 0x1e, 0x82, 0xbf, 0x4a, 0xd7, 0x9a, 0x8a, 0xde, 0x01, 0x74, 0x36, 0xd1, 0x77,
0xa2, 0x4a, 0xdb, 0x02, 0xf2, 0x15, 0xf4, 0xac, 0xd2, 0xb6, 0x6f, 0x18, 0xf3, 0xcf, 0x23, 0x9c,
0x83, 0x3f, 0x4f, 0x54, 0x56, 0x8c, 0xc0, 0xfb, 0xd0, 0xb3, 0x38, 0x6f, 0xc4, 0x43, 0xc0, 0x25,
0xe9, 0x05, 0x45, 0x71, 0xb2, 0x96, 0xe5, 0xa4, 0x08, 0xae, 0x5e, 0x7f, 0x50, 0xf1, 0xf7, 0xdb,
0x33, 0xbf, 0x84, 0x41, 0x4d, 0x69, 0x0d, 0xee, 0x61, 0xb4, 0x24, 0xbd, 0xcd, 0xee, 0x14, 0x93,
0x31, 0x5c, 0x1d, 0xa8, 0xad, 0xd1, 0x83, 0xa1, 0x4c, 0x0c, 0xa7, 0x38, 0x31, 0x08, 0x0e, 0xe5,
0xb9, 0xd5, 0xec, 0xa7, 0x05, 0xee, 0x5c, 0x49, 0x89, 0x8f, 0xe0, 0x6e, 0x7b, 0x21, 0xe6, 0x6f,
0x62, 0x5a, 0x79, 0x09, 0x6c, 0x50, 0xbb, 0xb3, 0xb9, 0xcf, 0xc0, 0x33, 0x96, 0x58, 0xb0, 0xd5,
0x05, 0xb2, 0x61, 0xfd, 0x72, 0x57, 0x63, 0x32, 0x2d, 0x6b, 0xaa, 0x89, 0x97, 0x35, 0xb5, 0xd8,
0x71, 0x01, 0xdd, 0x4a, 0x98, 0x38, 0xb6, 0xa2, 0xc3, 0x55, 0x30, 0x76, 0x8c, 0xb2, 0x2e, 0xcf,
0xd0, 0xdf, 0x4b, 0x13, 0xaf, 0x77, 0xf2, 0x23, 0x3b, 0x61, 0x37, 0x4d, 0xb4, 0x75, 0x5c, 0xc2,
0xc5, 0x7e, 0xaa, 0x58, 0xa9, 0x39, 0xb6, 0x1d, 0x76, 0xdb, 0xc8, 0xe7, 0xa6, 0x2f, 0x6d, 0xc3,
0x3f, 0xfd, 0x06, 0x00, 0x00, 0xff, 0xff, 0xe3, 0x73, 0x4d, 0x43, 0x9e, 0x03, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// ConnClient is the client API for Conn service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ConnClient interface {
Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error)
Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*WriteResponse, error)
Close(ctx context.Context, in *CloseRequest, opts ...grpc.CallOption) (*CloseResponse, error)
SetDeadline(ctx context.Context, in *SetDeadlineRequest, opts ...grpc.CallOption) (*SetDeadlineResponse, error)
SetReadDeadline(ctx context.Context, in *SetReadDeadlineRequest, opts ...grpc.CallOption) (*SetReadDeadlineResponse, error)
SetWriteDeadline(ctx context.Context, in *SetWriteDeadlineRequest, opts ...grpc.CallOption) (*SetWriteDeadlineResponse, error)
}
type connClient struct {
cc grpc.ClientConnInterface
}
func NewConnClient(cc grpc.ClientConnInterface) ConnClient {
return &connClient{cc}
}
func (c *connClient) Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error) {
out := new(ReadResponse)
err := c.cc.Invoke(ctx, "/proto.Conn/Read", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *connClient) Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*WriteResponse, error) {
out := new(WriteResponse)
err := c.cc.Invoke(ctx, "/proto.Conn/Write", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *connClient) Close(ctx context.Context, in *CloseRequest, opts ...grpc.CallOption) (*CloseResponse, error) {
out := new(CloseResponse)
err := c.cc.Invoke(ctx, "/proto.Conn/Close", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *connClient) SetDeadline(ctx context.Context, in *SetDeadlineRequest, opts ...grpc.CallOption) (*SetDeadlineResponse, error) {
out := new(SetDeadlineResponse)
err := c.cc.Invoke(ctx, "/proto.Conn/SetDeadline", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *connClient) SetReadDeadline(ctx context.Context, in *SetReadDeadlineRequest, opts ...grpc.CallOption) (*SetReadDeadlineResponse, error) {
out := new(SetReadDeadlineResponse)
err := c.cc.Invoke(ctx, "/proto.Conn/SetReadDeadline", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *connClient) SetWriteDeadline(ctx context.Context, in *SetWriteDeadlineRequest, opts ...grpc.CallOption) (*SetWriteDeadlineResponse, error) {
out := new(SetWriteDeadlineResponse)
err := c.cc.Invoke(ctx, "/proto.Conn/SetWriteDeadline", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ConnServer is the server API for Conn service.
type ConnServer interface {
Read(context.Context, *ReadRequest) (*ReadResponse, error)
Write(context.Context, *WriteRequest) (*WriteResponse, error)
Close(context.Context, *CloseRequest) (*CloseResponse, error)
SetDeadline(context.Context, *SetDeadlineRequest) (*SetDeadlineResponse, error)
SetReadDeadline(context.Context, *SetReadDeadlineRequest) (*SetReadDeadlineResponse, error)
SetWriteDeadline(context.Context, *SetWriteDeadlineRequest) (*SetWriteDeadlineResponse, error)
}
// UnimplementedConnServer can be embedded to have forward compatible implementations.
type UnimplementedConnServer struct {
}
func (*UnimplementedConnServer) Read(ctx context.Context, req *ReadRequest) (*ReadResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Read not implemented")
}
func (*UnimplementedConnServer) Write(ctx context.Context, req *WriteRequest) (*WriteResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Write not implemented")
}
func (*UnimplementedConnServer) Close(ctx context.Context, req *CloseRequest) (*CloseResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Close not implemented")
}
func (*UnimplementedConnServer) SetDeadline(ctx context.Context, req *SetDeadlineRequest) (*SetDeadlineResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SetDeadline not implemented")
}
func (*UnimplementedConnServer) SetReadDeadline(ctx context.Context, req *SetReadDeadlineRequest) (*SetReadDeadlineResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SetReadDeadline not implemented")
}
func (*UnimplementedConnServer) SetWriteDeadline(ctx context.Context, req *SetWriteDeadlineRequest) (*SetWriteDeadlineResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SetWriteDeadline not implemented")
}
func RegisterConnServer(s *grpc.Server, srv ConnServer) {
s.RegisterService(&_Conn_serviceDesc, srv)
}
func _Conn_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReadRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ConnServer).Read(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Conn/Read",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ConnServer).Read(ctx, req.(*ReadRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Conn_Write_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WriteRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ConnServer).Write(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Conn/Write",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ConnServer).Write(ctx, req.(*WriteRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Conn_Close_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CloseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ConnServer).Close(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Conn/Close",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ConnServer).Close(ctx, req.(*CloseRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Conn_SetDeadline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetDeadlineRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ConnServer).SetDeadline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Conn/SetDeadline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ConnServer).SetDeadline(ctx, req.(*SetDeadlineRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Conn_SetReadDeadline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetReadDeadlineRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ConnServer).SetReadDeadline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Conn/SetReadDeadline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ConnServer).SetReadDeadline(ctx, req.(*SetReadDeadlineRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Conn_SetWriteDeadline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetWriteDeadlineRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ConnServer).SetWriteDeadline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Conn/SetWriteDeadline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ConnServer).SetWriteDeadline(ctx, req.(*SetWriteDeadlineRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Conn_serviceDesc = grpc.ServiceDesc{
ServiceName: "proto.Conn",
HandlerType: (*ConnServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Read",
Handler: _Conn_Read_Handler,
},
{
MethodName: "Write",
Handler: _Conn_Write_Handler,
},
{
MethodName: "Close",
Handler: _Conn_Close_Handler,
},
{
MethodName: "SetDeadline",
Handler: _Conn_SetDeadline_Handler,
},
{
MethodName: "SetReadDeadline",
Handler: _Conn_SetReadDeadline_Handler,
},
{
MethodName: "SetWriteDeadline",
Handler: _Conn_SetWriteDeadline_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "conn.proto",
}

53
vms/rpcchainvm/ghttp/gconn/proto/conn.proto Normal file
View File

@ -0,0 +1,53 @@
syntax = "proto3";
package proto;
message ReadRequest {
int32 length = 1;
}
message ReadResponse {
bytes read = 1;
string error = 2;
bool errored = 3;
}
message WriteRequest {
bytes payload = 1;
}
message WriteResponse {
int32 length = 1;
string error = 2;
bool errored = 3;
}
message CloseRequest {}
message CloseResponse {}
message SetDeadlineRequest {
bytes time = 1;
}
message SetDeadlineResponse {}
message SetReadDeadlineRequest {
bytes time = 1;
}
message SetReadDeadlineResponse {}
message SetWriteDeadlineRequest {
bytes time = 1;
}
message SetWriteDeadlineResponse {}
service Conn {
rpc Read(ReadRequest) returns (ReadResponse);
rpc Write(WriteRequest) returns (WriteResponse);
rpc Close(CloseRequest) returns (CloseResponse);
rpc SetDeadline(SetDeadlineRequest) returns (SetDeadlineResponse);
rpc SetReadDeadline(SetReadDeadlineRequest) returns (SetReadDeadlineResponse);
rpc SetWriteDeadline(SetWriteDeadlineRequest) returns (SetWriteDeadlineResponse);
}

323
vms/rpcchainvm/ghttp/greadcloser/proto/reader.pb.go Normal file
View File

@ -0,0 +1,323 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: reader.proto
package proto
import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type ReadRequest struct {
Length int32 `protobuf:"varint,1,opt,name=length,proto3" json:"length,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ReadRequest) Reset() { *m = ReadRequest{} }
func (m *ReadRequest) String() string { return proto.CompactTextString(m) }
func (*ReadRequest) ProtoMessage() {}
func (*ReadRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_f534e48276761a43, []int{0}
}
func (m *ReadRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReadRequest.Unmarshal(m, b)
}
func (m *ReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ReadRequest.Marshal(b, m, deterministic)
}
func (m *ReadRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ReadRequest.Merge(m, src)
}
func (m *ReadRequest) XXX_Size() int {
return xxx_messageInfo_ReadRequest.Size(m)
}
func (m *ReadRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ReadRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ReadRequest proto.InternalMessageInfo
func (m *ReadRequest) GetLength() int32 {
if m != nil {
return m.Length
}
return 0
}
type ReadResponse struct {
Read []byte `protobuf:"bytes,1,opt,name=read,proto3" json:"read,omitempty"`
Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
Errored bool `protobuf:"varint,3,opt,name=errored,proto3" json:"errored,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ReadResponse) Reset() { *m = ReadResponse{} }
func (m *ReadResponse) String() string { return proto.CompactTextString(m) }
func (*ReadResponse) ProtoMessage() {}
func (*ReadResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_f534e48276761a43, []int{1}
}
func (m *ReadResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReadResponse.Unmarshal(m, b)
}
func (m *ReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ReadResponse.Marshal(b, m, deterministic)
}
func (m *ReadResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ReadResponse.Merge(m, src)
}
func (m *ReadResponse) XXX_Size() int {
return xxx_messageInfo_ReadResponse.Size(m)
}
func (m *ReadResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ReadResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ReadResponse proto.InternalMessageInfo
func (m *ReadResponse) GetRead() []byte {
if m != nil {
return m.Read
}
return nil
}
func (m *ReadResponse) GetError() string {
if m != nil {
return m.Error
}
return ""
}
func (m *ReadResponse) GetErrored() bool {
if m != nil {
return m.Errored
}
return false
}
type CloseRequest struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CloseRequest) Reset() { *m = CloseRequest{} }
func (m *CloseRequest) String() string { return proto.CompactTextString(m) }
func (*CloseRequest) ProtoMessage() {}
func (*CloseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_f534e48276761a43, []int{2}
}
func (m *CloseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CloseRequest.Unmarshal(m, b)
}
func (m *CloseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CloseRequest.Marshal(b, m, deterministic)
}
func (m *CloseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CloseRequest.Merge(m, src)
}
func (m *CloseRequest) XXX_Size() int {
return xxx_messageInfo_CloseRequest.Size(m)
}
func (m *CloseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CloseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CloseRequest proto.InternalMessageInfo
type CloseResponse struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CloseResponse) Reset() { *m = CloseResponse{} }
func (m *CloseResponse) String() string { return proto.CompactTextString(m) }
func (*CloseResponse) ProtoMessage() {}
func (*CloseResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_f534e48276761a43, []int{3}
}
func (m *CloseResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CloseResponse.Unmarshal(m, b)
}
func (m *CloseResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CloseResponse.Marshal(b, m, deterministic)
}
func (m *CloseResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CloseResponse.Merge(m, src)
}
func (m *CloseResponse) XXX_Size() int {
return xxx_messageInfo_CloseResponse.Size(m)
}
func (m *CloseResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CloseResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CloseResponse proto.InternalMessageInfo
func init() {
proto.RegisterType((*ReadRequest)(nil), "proto.ReadRequest")
proto.RegisterType((*ReadResponse)(nil), "proto.ReadResponse")
proto.RegisterType((*CloseRequest)(nil), "proto.CloseRequest")
proto.RegisterType((*CloseResponse)(nil), "proto.CloseResponse")
}
func init() { proto.RegisterFile("reader.proto", fileDescriptor_f534e48276761a43) }
var fileDescriptor_f534e48276761a43 = []byte{
// 195 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x8e, 0xd1, 0x6a, 0x84, 0x30,
0x10, 0x45, 0x49, 0x6b, 0x6c, 0x3b, 0x4d, 0x5b, 0x98, 0x4a, 0x09, 0x3e, 0x49, 0xa0, 0xe0, 0x93,
0x0b, 0xee, 0x27, 0xec, 0x1f, 0xcc, 0x1f, 0xb8, 0x38, 0xec, 0x3e, 0xb8, 0xc6, 0x4d, 0xdc, 0xff,
0x5f, 0x4c, 0x22, 0xe8, 0x53, 0xee, 0xbd, 0x99, 0x99, 0x7b, 0x40, 0x39, 0xee, 0x7a, 0x76, 0xcd,
0xe4, 0xec, 0x6c, 0x51, 0x86, 0xc7, 0xfc, 0xc3, 0x27, 0x71, 0xd7, 0x13, 0xdf, 0x1f, 0xec, 0x67,
0xfc, 0x83, 0x7c, 0xe0, 0xf1, 0x32, 0x5f, 0xb5, 0xa8, 0x44, 0x2d, 0x29, 0x39, 0x43, 0xa0, 0xe2,
0x98, 0x9f, 0xec, 0xe8, 0x19, 0x11, 0xb2, 0xe5, 0x5a, 0x98, 0x52, 0x14, 0x34, 0x16, 0x20, 0xd9,
0x39, 0xeb, 0xf4, 0x4b, 0x25, 0xea, 0x0f, 0x8a, 0x06, 0x35, 0xbc, 0x05, 0xc1, 0xbd, 0x7e, 0xad,
0x44, 0xfd, 0x4e, 0xab, 0x35, 0xdf, 0xa0, 0x4e, 0x83, 0xf5, 0x9c, 0xba, 0xcd, 0x0f, 0x7c, 0x25,
0x1f, 0x4b, 0xda, 0x1b, 0xe4, 0x14, 0x90, 0xf1, 0x00, 0xd9, 0xa2, 0x10, 0x23, 0x7c, 0xb3, 0x41,
0x2e, 0x7f, 0x77, 0x59, 0xe2, 0x6b, 0x41, 0x86, 0x5b, 0xb8, 0xfe, 0x6e, 0x9b, 0xca, 0x62, 0x1f,
0xc6, 0x9d, 0x73, 0x1e, 0xc2, 0xe3, 0x33, 0x00, 0x00, 0xff, 0xff, 0x47, 0x74, 0x81, 0x61, 0x28,
0x01, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// ReaderClient is the client API for Reader service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ReaderClient interface {
Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error)
Close(ctx context.Context, in *CloseRequest, opts ...grpc.CallOption) (*CloseResponse, error)
}
type readerClient struct {
cc grpc.ClientConnInterface
}
func NewReaderClient(cc grpc.ClientConnInterface) ReaderClient {
return &readerClient{cc}
}
func (c *readerClient) Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error) {
out := new(ReadResponse)
err := c.cc.Invoke(ctx, "/proto.Reader/Read", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *readerClient) Close(ctx context.Context, in *CloseRequest, opts ...grpc.CallOption) (*CloseResponse, error) {
out := new(CloseResponse)
err := c.cc.Invoke(ctx, "/proto.Reader/Close", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ReaderServer is the server API for Reader service.
type ReaderServer interface {
Read(context.Context, *ReadRequest) (*ReadResponse, error)
Close(context.Context, *CloseRequest) (*CloseResponse, error)
}
// UnimplementedReaderServer can be embedded to have forward compatible implementations.
type UnimplementedReaderServer struct {
}
func (*UnimplementedReaderServer) Read(ctx context.Context, req *ReadRequest) (*ReadResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Read not implemented")
}
func (*UnimplementedReaderServer) Close(ctx context.Context, req *CloseRequest) (*CloseResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Close not implemented")
}
func RegisterReaderServer(s *grpc.Server, srv ReaderServer) {
s.RegisterService(&_Reader_serviceDesc, srv)
}
func _Reader_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReadRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ReaderServer).Read(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Reader/Read",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ReaderServer).Read(ctx, req.(*ReadRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Reader_Close_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CloseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ReaderServer).Close(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Reader/Close",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ReaderServer).Close(ctx, req.(*CloseRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Reader_serviceDesc = grpc.ServiceDesc{
ServiceName: "proto.Reader",
HandlerType: (*ReaderServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Read",
Handler: _Reader_Read_Handler,
},
{
MethodName: "Close",
Handler: _Reader_Close_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "reader.proto",
}

21
vms/rpcchainvm/ghttp/greadcloser/proto/reader.proto Normal file
View File

@ -0,0 +1,21 @@
syntax = "proto3";
package proto;
message ReadRequest {
int32 length = 1;
}
message ReadResponse {
bytes read = 1;
string error = 2;
bool errored = 3;
}
message CloseRequest {}
message CloseResponse {}
service Reader {
rpc Read(ReadRequest) returns (ReadResponse);
rpc Close(CloseRequest) returns (CloseResponse);
}

42
vms/rpcchainvm/ghttp/greadcloser/reader_client.go Normal file
View File

@ -0,0 +1,42 @@
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package greadcloser
import (
"context"
"errors"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greadcloser/proto"
)
// Client is an implementation of a messenger channel that talks over RPC.
type Client struct{ client proto.ReaderClient }
// NewClient returns a database instance connected to a remote database instance
func NewClient(client proto.ReaderClient) *Client {
return &Client{client: client}
}
// Read ...
func (c *Client) Read(p []byte) (int, error) {
resp, err := c.client.Read(context.Background(), &proto.ReadRequest{
Length: int32(len(p)),
})
if err != nil {
return 0, err
}
copy(p, resp.Read)
if resp.Errored {
err = errors.New(resp.Error)
}
return len(resp.Read), err
}
// Close ...
func (c *Client) Close() error {
_, err := c.client.Close(context.Background(), &proto.CloseRequest{})
return err
}

38
vms/rpcchainvm/ghttp/greadcloser/reader_server.go Normal file
View File

@ -0,0 +1,38 @@
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package greadcloser
import (
"context"
"io"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greadcloser/proto"
)
// Server is a http.Handler that is managed over RPC.
type Server struct{ readCloser io.ReadCloser }
// NewServer returns a http.Handler instance manage remotely
func NewServer(readCloser io.ReadCloser) *Server {
return &Server{readCloser: readCloser}
}
// Read ...
func (s *Server) Read(ctx context.Context, req *proto.ReadRequest) (*proto.ReadResponse, error) {
buf := make([]byte, int(req.Length))
n, err := s.readCloser.Read(buf)
resp := &proto.ReadResponse{
Read: buf[:n],
}
if err != nil {
resp.Errored = true
resp.Error = err.Error()
}
return resp, nil
}
// Close ...
func (s *Server) Close(ctx context.Context, req *proto.CloseRequest) (*proto.CloseResponse, error) {
return &proto.CloseResponse{}, s.readCloser.Close()
}

221
vms/rpcchainvm/ghttp/greader/proto/reader.pb.go Normal file
View File

@ -0,0 +1,221 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: reader.proto
package proto
import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type ReadRequest struct {
Length int32 `protobuf:"varint,1,opt,name=length,proto3" json:"length,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ReadRequest) Reset() { *m = ReadRequest{} }
func (m *ReadRequest) String() string { return proto.CompactTextString(m) }
func (*ReadRequest) ProtoMessage() {}
func (*ReadRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_f534e48276761a43, []int{0}
}
func (m *ReadRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReadRequest.Unmarshal(m, b)
}
func (m *ReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ReadRequest.Marshal(b, m, deterministic)
}
func (m *ReadRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ReadRequest.Merge(m, src)
}
func (m *ReadRequest) XXX_Size() int {
return xxx_messageInfo_ReadRequest.Size(m)
}
func (m *ReadRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ReadRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ReadRequest proto.InternalMessageInfo
func (m *ReadRequest) GetLength() int32 {
if m != nil {
return m.Length
}
return 0
}
type ReadResponse struct {
Read []byte `protobuf:"bytes,1,opt,name=read,proto3" json:"read,omitempty"`
Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
Errored bool `protobuf:"varint,3,opt,name=errored,proto3" json:"errored,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ReadResponse) Reset() { *m = ReadResponse{} }
func (m *ReadResponse) String() string { return proto.CompactTextString(m) }
func (*ReadResponse) ProtoMessage() {}
func (*ReadResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_f534e48276761a43, []int{1}
}
func (m *ReadResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReadResponse.Unmarshal(m, b)
}
func (m *ReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ReadResponse.Marshal(b, m, deterministic)
}
func (m *ReadResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ReadResponse.Merge(m, src)
}
func (m *ReadResponse) XXX_Size() int {
return xxx_messageInfo_ReadResponse.Size(m)
}
func (m *ReadResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ReadResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ReadResponse proto.InternalMessageInfo
func (m *ReadResponse) GetRead() []byte {
if m != nil {
return m.Read
}
return nil
}
func (m *ReadResponse) GetError() string {
if m != nil {
return m.Error
}
return ""
}
func (m *ReadResponse) GetErrored() bool {
if m != nil {
return m.Errored
}
return false
}
func init() {
proto.RegisterType((*ReadRequest)(nil), "proto.ReadRequest")
proto.RegisterType((*ReadResponse)(nil), "proto.ReadResponse")
}
func init() { proto.RegisterFile("reader.proto", fileDescriptor_f534e48276761a43) }
var fileDescriptor_f534e48276761a43 = []byte{
// 162 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x8e, 0x41, 0x0a, 0xc2, 0x30,
0x10, 0x45, 0x89, 0xb6, 0x55, 0xc7, 0xae, 0x46, 0x91, 0xe0, 0xaa, 0x14, 0x84, 0xac, 0x2a, 0xe8,
0xca, 0x6b, 0xcc, 0x0d, 0x2a, 0x19, 0x74, 0x21, 0x4d, 0x9d, 0xc4, 0xfb, 0x4b, 0x27, 0x0a, 0xba,
0xca, 0x7f, 0x9f, 0x4f, 0xe6, 0x41, 0x2d, 0xdc, 0x7b, 0x96, 0x6e, 0x94, 0x90, 0x02, 0x96, 0xfa,
0xb4, 0x07, 0x58, 0x13, 0xf7, 0x9e, 0xf8, 0xf9, 0xe2, 0x98, 0x70, 0x07, 0xd5, 0x83, 0x87, 0x5b,
0xba, 0x5b, 0xd3, 0x18, 0x57, 0xd2, 0x87, 0x5a, 0x82, 0x3a, 0xcf, 0xe2, 0x18, 0x86, 0xc8, 0x88,
0x50, 0x4c, 0xbf, 0xe9, 0xaa, 0x26, 0xcd, 0xb8, 0x85, 0x92, 0x45, 0x82, 0xd8, 0x59, 0x63, 0xdc,
0x8a, 0x32, 0xa0, 0x85, 0x85, 0x06, 0xf6, 0x76, 0xde, 0x18, 0xb7, 0xa4, 0x2f, 0x9e, 0x2e, 0x50,
0x91, 0x1a, 0xe1, 0x11, 0x8a, 0x29, 0x21, 0x66, 0xb7, 0xee, 0xc7, 0x68, 0xbf, 0xf9, 0xeb, 0xf2,
0xf9, 0x6b, 0xa5, 0xdd, 0xf9, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x06, 0x11, 0x6f, 0x5d, 0xd3, 0x00,
0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// ReaderClient is the client API for Reader service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ReaderClient interface {
Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error)
}
type readerClient struct {
cc grpc.ClientConnInterface
}
func NewReaderClient(cc grpc.ClientConnInterface) ReaderClient {
return &readerClient{cc}
}
func (c *readerClient) Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error) {
out := new(ReadResponse)
err := c.cc.Invoke(ctx, "/proto.Reader/Read", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ReaderServer is the server API for Reader service.
type ReaderServer interface {
Read(context.Context, *ReadRequest) (*ReadResponse, error)
}
// UnimplementedReaderServer can be embedded to have forward compatible implementations.
type UnimplementedReaderServer struct {
}
func (*UnimplementedReaderServer) Read(ctx context.Context, req *ReadRequest) (*ReadResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Read not implemented")
}
func RegisterReaderServer(s *grpc.Server, srv ReaderServer) {
s.RegisterService(&_Reader_serviceDesc, srv)
}
func _Reader_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReadRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ReaderServer).Read(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Reader/Read",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ReaderServer).Read(ctx, req.(*ReadRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Reader_serviceDesc = grpc.ServiceDesc{
ServiceName: "proto.Reader",
HandlerType: (*ReaderServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Read",
Handler: _Reader_Read_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "reader.proto",
}

16
vms/rpcchainvm/ghttp/greader/proto/reader.proto Normal file
View File

@ -0,0 +1,16 @@
syntax = "proto3";
package proto;
message ReadRequest {
int32 length = 1;
}
message ReadResponse {
bytes read = 1;
string error = 2;
bool errored = 3;
}
service Reader {
rpc Read(ReadRequest) returns (ReadResponse);
}

36
vms/rpcchainvm/ghttp/greader/reader_client.go Normal file
View File

@ -0,0 +1,36 @@
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package greader
import (
"context"
"errors"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greader/proto"
)
// Client is an implementation of a messenger channel that talks over RPC.
type Client struct{ client proto.ReaderClient }
// NewClient returns a database instance connected to a remote database instance
func NewClient(client proto.ReaderClient) *Client {
return &Client{client: client}
}
// Read ...
func (c *Client) Read(p []byte) (int, error) {
resp, err := c.client.Read(context.Background(), &proto.ReadRequest{
Length: int32(len(p)),
})
if err != nil {
return 0, err
}
copy(p, resp.Read)
if resp.Errored {
err = errors.New(resp.Error)
}
return len(resp.Read), err
}

33
vms/rpcchainvm/ghttp/greader/reader_server.go Normal file
View File

@ -0,0 +1,33 @@
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package greader
import (
"context"
"io"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greader/proto"
)
// Server is a http.Handler that is managed over RPC.
type Server struct{ reader io.Reader }
// NewServer returns a http.Handler instance manage remotely
func NewServer(reader io.Reader) *Server {
return &Server{reader: reader}
}
// Read ...
func (s *Server) Read(ctx context.Context, req *proto.ReadRequest) (*proto.ReadResponse, error) {
buf := make([]byte, int(req.Length))
n, err := s.reader.Read(buf)
resp := &proto.ReadResponse{
Read: buf[:n],
}
if err != nil {
resp.Errored = true
resp.Error = err.Error()
}
return resp, nil
}

648
vms/rpcchainvm/ghttp/gresponsewriter/proto/writer.pb.go Normal file
View File

@ -0,0 +1,648 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: writer.proto
package proto
import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type Header struct {
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
Values []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Header) Reset() { *m = Header{} }
func (m *Header) String() string { return proto.CompactTextString(m) }
func (*Header) ProtoMessage() {}
func (*Header) Descriptor() ([]byte, []int) {
return fileDescriptor_ea6fbe89c42e6759, []int{0}
}
func (m *Header) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Header.Unmarshal(m, b)
}
func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Header.Marshal(b, m, deterministic)
}
func (m *Header) XXX_Merge(src proto.Message) {
xxx_messageInfo_Header.Merge(m, src)
}
func (m *Header) XXX_Size() int {
return xxx_messageInfo_Header.Size(m)
}
func (m *Header) XXX_DiscardUnknown() {
xxx_messageInfo_Header.DiscardUnknown(m)
}
var xxx_messageInfo_Header proto.InternalMessageInfo
func (m *Header) GetKey() string {
if m != nil {
return m.Key
}
return ""
}
func (m *Header) GetValues() []string {
if m != nil {
return m.Values
}
return nil
}
type WriteRequest struct {
Headers []*Header `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty"`
Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WriteRequest) Reset() { *m = WriteRequest{} }
func (m *WriteRequest) String() string { return proto.CompactTextString(m) }
func (*WriteRequest) ProtoMessage() {}
func (*WriteRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ea6fbe89c42e6759, []int{1}
}
func (m *WriteRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_WriteRequest.Unmarshal(m, b)
}
func (m *WriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WriteRequest.Marshal(b, m, deterministic)
}
func (m *WriteRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_WriteRequest.Merge(m, src)
}
func (m *WriteRequest) XXX_Size() int {
return xxx_messageInfo_WriteRequest.Size(m)
}
func (m *WriteRequest) XXX_DiscardUnknown() {
xxx_messageInfo_WriteRequest.DiscardUnknown(m)
}
var xxx_messageInfo_WriteRequest proto.InternalMessageInfo
func (m *WriteRequest) GetHeaders() []*Header {
if m != nil {
return m.Headers
}
return nil
}
func (m *WriteRequest) GetPayload() []byte {
if m != nil {
return m.Payload
}
return nil
}
type WriteResponse struct {
Written int32 `protobuf:"varint,1,opt,name=written,proto3" json:"written,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WriteResponse) Reset() { *m = WriteResponse{} }
func (m *WriteResponse) String() string { return proto.CompactTextString(m) }
func (*WriteResponse) ProtoMessage() {}
func (*WriteResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ea6fbe89c42e6759, []int{2}
}
func (m *WriteResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_WriteResponse.Unmarshal(m, b)
}
func (m *WriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WriteResponse.Marshal(b, m, deterministic)
}
func (m *WriteResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_WriteResponse.Merge(m, src)
}
func (m *WriteResponse) XXX_Size() int {
return xxx_messageInfo_WriteResponse.Size(m)
}
func (m *WriteResponse) XXX_DiscardUnknown() {
xxx_messageInfo_WriteResponse.DiscardUnknown(m)
}
var xxx_messageInfo_WriteResponse proto.InternalMessageInfo
func (m *WriteResponse) GetWritten() int32 {
if m != nil {
return m.Written
}
return 0
}
type WriteHeaderRequest struct {
Headers []*Header `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty"`
StatusCode int32 `protobuf:"varint,2,opt,name=statusCode,proto3" json:"statusCode,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WriteHeaderRequest) Reset() { *m = WriteHeaderRequest{} }
func (m *WriteHeaderRequest) String() string { return proto.CompactTextString(m) }
func (*WriteHeaderRequest) ProtoMessage() {}
func (*WriteHeaderRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ea6fbe89c42e6759, []int{3}
}
func (m *WriteHeaderRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_WriteHeaderRequest.Unmarshal(m, b)
}
func (m *WriteHeaderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WriteHeaderRequest.Marshal(b, m, deterministic)
}
func (m *WriteHeaderRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_WriteHeaderRequest.Merge(m, src)
}
func (m *WriteHeaderRequest) XXX_Size() int {
return xxx_messageInfo_WriteHeaderRequest.Size(m)
}
func (m *WriteHeaderRequest) XXX_DiscardUnknown() {
xxx_messageInfo_WriteHeaderRequest.DiscardUnknown(m)
}
var xxx_messageInfo_WriteHeaderRequest proto.InternalMessageInfo
func (m *WriteHeaderRequest) GetHeaders() []*Header {
if m != nil {
return m.Headers
}
return nil
}
func (m *WriteHeaderRequest) GetStatusCode() int32 {
if m != nil {
return m.StatusCode
}
return 0
}
type WriteHeaderResponse struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WriteHeaderResponse) Reset() { *m = WriteHeaderResponse{} }
func (m *WriteHeaderResponse) String() string { return proto.CompactTextString(m) }
func (*WriteHeaderResponse) ProtoMessage() {}
func (*WriteHeaderResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ea6fbe89c42e6759, []int{4}
}
func (m *WriteHeaderResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_WriteHeaderResponse.Unmarshal(m, b)
}
func (m *WriteHeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WriteHeaderResponse.Marshal(b, m, deterministic)
}
func (m *WriteHeaderResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_WriteHeaderResponse.Merge(m, src)
}
func (m *WriteHeaderResponse) XXX_Size() int {
return xxx_messageInfo_WriteHeaderResponse.Size(m)
}
func (m *WriteHeaderResponse) XXX_DiscardUnknown() {
xxx_messageInfo_WriteHeaderResponse.DiscardUnknown(m)
}
var xxx_messageInfo_WriteHeaderResponse proto.InternalMessageInfo
type FlushRequest struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FlushRequest) Reset() { *m = FlushRequest{} }
func (m *FlushRequest) String() string { return proto.CompactTextString(m) }
func (*FlushRequest) ProtoMessage() {}
func (*FlushRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ea6fbe89c42e6759, []int{5}
}
func (m *FlushRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FlushRequest.Unmarshal(m, b)
}
func (m *FlushRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FlushRequest.Marshal(b, m, deterministic)
}
func (m *FlushRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_FlushRequest.Merge(m, src)
}
func (m *FlushRequest) XXX_Size() int {
return xxx_messageInfo_FlushRequest.Size(m)
}
func (m *FlushRequest) XXX_DiscardUnknown() {
xxx_messageInfo_FlushRequest.DiscardUnknown(m)
}
var xxx_messageInfo_FlushRequest proto.InternalMessageInfo
type FlushResponse struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FlushResponse) Reset() { *m = FlushResponse{} }
func (m *FlushResponse) String() string { return proto.CompactTextString(m) }
func (*FlushResponse) ProtoMessage() {}
func (*FlushResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ea6fbe89c42e6759, []int{6}
}
func (m *FlushResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FlushResponse.Unmarshal(m, b)
}
func (m *FlushResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FlushResponse.Marshal(b, m, deterministic)
}
func (m *FlushResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_FlushResponse.Merge(m, src)
}
func (m *FlushResponse) XXX_Size() int {
return xxx_messageInfo_FlushResponse.Size(m)
}
func (m *FlushResponse) XXX_DiscardUnknown() {
xxx_messageInfo_FlushResponse.DiscardUnknown(m)
}
var xxx_messageInfo_FlushResponse proto.InternalMessageInfo
type HijackRequest struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *HijackRequest) Reset() { *m = HijackRequest{} }
func (m *HijackRequest) String() string { return proto.CompactTextString(m) }
func (*HijackRequest) ProtoMessage() {}
func (*HijackRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ea6fbe89c42e6759, []int{7}
}
func (m *HijackRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_HijackRequest.Unmarshal(m, b)
}
func (m *HijackRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_HijackRequest.Marshal(b, m, deterministic)
}
func (m *HijackRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_HijackRequest.Merge(m, src)
}
func (m *HijackRequest) XXX_Size() int {
return xxx_messageInfo_HijackRequest.Size(m)
}
func (m *HijackRequest) XXX_DiscardUnknown() {
xxx_messageInfo_HijackRequest.DiscardUnknown(m)
}
var xxx_messageInfo_HijackRequest proto.InternalMessageInfo
type HijackResponse struct {
ConnServer uint32 `protobuf:"varint,1,opt,name=connServer,proto3" json:"connServer,omitempty"`
LocalNetwork string `protobuf:"bytes,2,opt,name=localNetwork,proto3" json:"localNetwork,omitempty"`
LocalString string `protobuf:"bytes,3,opt,name=localString,proto3" json:"localString,omitempty"`
RemoteNetwork string `protobuf:"bytes,4,opt,name=remoteNetwork,proto3" json:"remoteNetwork,omitempty"`
RemoteString string `protobuf:"bytes,5,opt,name=remoteString,proto3" json:"remoteString,omitempty"`
ReaderServer uint32 `protobuf:"varint,6,opt,name=readerServer,proto3" json:"readerServer,omitempty"`
WriterServer uint32 `protobuf:"varint,7,opt,name=writerServer,proto3" json:"writerServer,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *HijackResponse) Reset() { *m = HijackResponse{} }
func (m *HijackResponse) String() string { return proto.CompactTextString(m) }
func (*HijackResponse) ProtoMessage() {}
func (*HijackResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ea6fbe89c42e6759, []int{8}
}
func (m *HijackResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_HijackResponse.Unmarshal(m, b)
}
func (m *HijackResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_HijackResponse.Marshal(b, m, deterministic)
}
func (m *HijackResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_HijackResponse.Merge(m, src)
}
func (m *HijackResponse) XXX_Size() int {
return xxx_messageInfo_HijackResponse.Size(m)
}
func (m *HijackResponse) XXX_DiscardUnknown() {
xxx_messageInfo_HijackResponse.DiscardUnknown(m)
}
var xxx_messageInfo_HijackResponse proto.InternalMessageInfo
func (m *HijackResponse) GetConnServer() uint32 {
if m != nil {
return m.ConnServer
}
return 0
}
func (m *HijackResponse) GetLocalNetwork() string {
if m != nil {
return m.LocalNetwork
}
return ""
}
func (m *HijackResponse) GetLocalString() string {
if m != nil {
return m.LocalString
}
return ""
}
func (m *HijackResponse) GetRemoteNetwork() string {
if m != nil {
return m.RemoteNetwork
}
return ""
}
func (m *HijackResponse) GetRemoteString() string {
if m != nil {
return m.RemoteString
}
return ""
}
func (m *HijackResponse) GetReaderServer() uint32 {
if m != nil {
return m.ReaderServer
}
return 0
}
func (m *HijackResponse) GetWriterServer() uint32 {
if m != nil {
return m.WriterServer
}
return 0
}
func init() {
proto.RegisterType((*Header)(nil), "proto.Header")
proto.RegisterType((*WriteRequest)(nil), "proto.WriteRequest")
proto.RegisterType((*WriteResponse)(nil), "proto.WriteResponse")
proto.RegisterType((*WriteHeaderRequest)(nil), "proto.WriteHeaderRequest")
proto.RegisterType((*WriteHeaderResponse)(nil), "proto.WriteHeaderResponse")
proto.RegisterType((*FlushRequest)(nil), "proto.FlushRequest")
proto.RegisterType((*FlushResponse)(nil), "proto.FlushResponse")
proto.RegisterType((*HijackRequest)(nil), "proto.HijackRequest")
proto.RegisterType((*HijackResponse)(nil), "proto.HijackResponse")
}
func init() { proto.RegisterFile("writer.proto", fileDescriptor_ea6fbe89c42e6759) }
var fileDescriptor_ea6fbe89c42e6759 = []byte{
// 408 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0x41, 0x6e, 0xe2, 0x30,
0x14, 0x86, 0x15, 0x32, 0x09, 0xe2, 0x91, 0xc0, 0xc8, 0x0c, 0xa3, 0x4c, 0x16, 0x28, 0xb2, 0x46,
0x9a, 0xcc, 0x86, 0x45, 0xaa, 0x9e, 0xa0, 0x55, 0xc5, 0xaa, 0x52, 0xcd, 0xa2, 0xab, 0x2e, 0x52,
0xb0, 0x0a, 0x25, 0x8d, 0xa9, 0xed, 0x80, 0xb8, 0x41, 0x2f, 0xdb, 0x3b, 0x54, 0xb1, 0x1d, 0x64,
0x57, 0xdd, 0x74, 0x15, 0xbf, 0xcf, 0x7f, 0xfe, 0xf7, 0xdb, 0xcf, 0x10, 0x1d, 0xf9, 0x56, 0x52,
0x3e, 0xdf, 0x73, 0x26, 0x19, 0x0a, 0xd4, 0x07, 0x17, 0x10, 0x2e, 0x68, 0xb9, 0xa6, 0x1c, 0xfd,
0x04, 0x7f, 0x47, 0x4f, 0x89, 0x97, 0x79, 0xf9, 0x80, 0xb4, 0x4b, 0xf4, 0x1b, 0xc2, 0x43, 0x59,
0x35, 0x54, 0x24, 0xbd, 0xcc, 0xcf, 0x07, 0xc4, 0x54, 0xf8, 0x0e, 0xa2, 0xfb, 0xd6, 0x8a, 0xd0,
0xd7, 0x86, 0x0a, 0x89, 0xfe, 0x41, 0x7f, 0xa3, 0x3c, 0x44, 0xe2, 0x65, 0x7e, 0x3e, 0x2c, 0x62,
0xdd, 0x63, 0xae, 0x9d, 0x49, 0xb7, 0x8b, 0x12, 0xe8, 0xef, 0xcb, 0x53, 0xc5, 0xca, 0x75, 0xd2,
0xcb, 0xbc, 0x3c, 0x22, 0x5d, 0x89, 0xff, 0x43, 0x6c, 0x2c, 0xc5, 0x9e, 0xd5, 0x82, 0xb6, 0xd2,
0x36, 0xae, 0xa4, 0xb5, 0x4a, 0x14, 0x90, 0xae, 0xc4, 0x0f, 0x80, 0x94, 0xd4, 0x98, 0x7f, 0x37,
0xc3, 0x0c, 0x40, 0xc8, 0x52, 0x36, 0xe2, 0x8a, 0xad, 0xa9, 0x8a, 0x11, 0x10, 0x8b, 0xe0, 0x29,
0x4c, 0x1c, 0x7b, 0x9d, 0x07, 0x8f, 0x20, 0xba, 0xa9, 0x1a, 0xb1, 0x31, 0xfd, 0xf0, 0x18, 0x62,
0x53, 0x1b, 0xc1, 0x18, 0xe2, 0xc5, 0xf6, 0xb9, 0x5c, 0xed, 0x3a, 0xc5, 0x5b, 0x0f, 0x46, 0x1d,
0x31, 0x87, 0x9a, 0x01, 0xac, 0x58, 0x5d, 0x2f, 0x29, 0x3f, 0x50, 0xae, 0xce, 0x15, 0x13, 0x8b,
0x20, 0x0c, 0x51, 0xc5, 0x56, 0x65, 0x75, 0x4b, 0xe5, 0x91, 0xf1, 0x9d, 0x4a, 0x37, 0x20, 0x0e,
0x43, 0x19, 0x0c, 0x55, 0xbd, 0x94, 0x7c, 0x5b, 0x3f, 0x25, 0xbe, 0x92, 0xd8, 0x08, 0xfd, 0x85,
0x98, 0xd3, 0x17, 0x26, 0x69, 0x67, 0xf3, 0x43, 0x69, 0x5c, 0xd8, 0xf6, 0xd2, 0xc0, 0x18, 0x05,
0xba, 0x97, 0xcd, 0xb4, 0xa6, 0xbd, 0x06, 0x93, 0x38, 0x54, 0x89, 0x1d, 0xd6, 0x6a, 0xf4, 0xbb,
0x32, 0x9a, 0xbe, 0xd6, 0xd8, 0xac, 0x78, 0xf7, 0x20, 0x54, 0x97, 0xca, 0x51, 0x01, 0x81, 0x5a,
0xa1, 0x89, 0x99, 0x8f, 0xfd, 0x92, 0xd2, 0x5f, 0x2e, 0x34, 0xd7, 0x76, 0x0d, 0x43, 0x6b, 0x24,
0xe8, 0x8f, 0x2d, 0x72, 0x5e, 0x41, 0x9a, 0x7e, 0xb5, 0x65, 0x5c, 0x0a, 0x08, 0xd4, 0xc4, 0xce,
0x9d, 0xed, 0x79, 0x9e, 0x3b, 0x3b, 0x43, 0x45, 0x97, 0x10, 0xea, 0x11, 0xa2, 0x6e, 0xdf, 0x99,
0x71, 0x3a, 0xfd, 0x44, 0xf5, 0x6f, 0x8f, 0xa1, 0xa2, 0x17, 0x1f, 0x01, 0x00, 0x00, 0xff, 0xff,
0x6f, 0xbe, 0x4a, 0x4f, 0x72, 0x03, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// WriterClient is the client API for Writer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type WriterClient interface {
Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*WriteResponse, error)
WriteHeader(ctx context.Context, in *WriteHeaderRequest, opts ...grpc.CallOption) (*WriteHeaderResponse, error)
Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*FlushResponse, error)
Hijack(ctx context.Context, in *HijackRequest, opts ...grpc.CallOption) (*HijackResponse, error)
}
type writerClient struct {
cc grpc.ClientConnInterface
}
func NewWriterClient(cc grpc.ClientConnInterface) WriterClient {
return &writerClient{cc}
}
func (c *writerClient) Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*WriteResponse, error) {
out := new(WriteResponse)
err := c.cc.Invoke(ctx, "/proto.Writer/Write", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *writerClient) WriteHeader(ctx context.Context, in *WriteHeaderRequest, opts ...grpc.CallOption) (*WriteHeaderResponse, error) {
out := new(WriteHeaderResponse)
err := c.cc.Invoke(ctx, "/proto.Writer/WriteHeader", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *writerClient) Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*FlushResponse, error) {
out := new(FlushResponse)
err := c.cc.Invoke(ctx, "/proto.Writer/Flush", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *writerClient) Hijack(ctx context.Context, in *HijackRequest, opts ...grpc.CallOption) (*HijackResponse, error) {
out := new(HijackResponse)
err := c.cc.Invoke(ctx, "/proto.Writer/Hijack", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// WriterServer is the server API for Writer service.
type WriterServer interface {
Write(context.Context, *WriteRequest) (*WriteResponse, error)
WriteHeader(context.Context, *WriteHeaderRequest) (*WriteHeaderResponse, error)
Flush(context.Context, *FlushRequest) (*FlushResponse, error)
Hijack(context.Context, *HijackRequest) (*HijackResponse, error)
}
// UnimplementedWriterServer can be embedded to have forward compatible implementations.
type UnimplementedWriterServer struct {
}
func (*UnimplementedWriterServer) Write(ctx context.Context, req *WriteRequest) (*WriteResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Write not implemented")
}
func (*UnimplementedWriterServer) WriteHeader(ctx context.Context, req *WriteHeaderRequest) (*WriteHeaderResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WriteHeader not implemented")
}
func (*UnimplementedWriterServer) Flush(ctx context.Context, req *FlushRequest) (*FlushResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Flush not implemented")
}
func (*UnimplementedWriterServer) Hijack(ctx context.Context, req *HijackRequest) (*HijackResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Hijack not implemented")
}
func RegisterWriterServer(s *grpc.Server, srv WriterServer) {
s.RegisterService(&_Writer_serviceDesc, srv)
}
func _Writer_Write_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WriteRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WriterServer).Write(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Writer/Write",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WriterServer).Write(ctx, req.(*WriteRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Writer_WriteHeader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WriteHeaderRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WriterServer).WriteHeader(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Writer/WriteHeader",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WriterServer).WriteHeader(ctx, req.(*WriteHeaderRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Writer_Flush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(FlushRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WriterServer).Flush(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Writer/Flush",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WriterServer).Flush(ctx, req.(*FlushRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Writer_Hijack_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(HijackRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WriterServer).Hijack(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Writer/Hijack",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WriterServer).Hijack(ctx, req.(*HijackRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Writer_serviceDesc = grpc.ServiceDesc{
ServiceName: "proto.Writer",
HandlerType: (*WriterServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Write",
Handler: _Writer_Write_Handler,
},
{
MethodName: "WriteHeader",
Handler: _Writer_WriteHeader_Handler,
},
{
MethodName: "Flush",
Handler: _Writer_Flush_Handler,
},
{
MethodName: "Hijack",
Handler: _Writer_Hijack_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "writer.proto",
}

46
vms/rpcchainvm/ghttp/gresponsewriter/proto/writer.proto Normal file
View File

@ -0,0 +1,46 @@
syntax = "proto3";
package proto;
message Header {
string key = 1;
repeated string values = 2;
}
message WriteRequest {
repeated Header headers = 1;
bytes payload = 2;
}
message WriteResponse {
int32 written = 1;
}
message WriteHeaderRequest {
repeated Header headers = 1;
int32 statusCode = 2;
}
message WriteHeaderResponse {}
message FlushRequest {}
message FlushResponse {}
message HijackRequest {}
message HijackResponse {
uint32 connServer = 1;
string localNetwork = 2;
string localString = 3;
string remoteNetwork = 4;
string remoteString = 5;
uint32 readerServer = 6;
uint32 writerServer = 7;
}
service Writer {
rpc Write(WriteRequest) returns (WriteResponse);
rpc WriteHeader(WriteHeaderRequest) returns (WriteHeaderResponse);
rpc Flush(FlushRequest) returns (FlushResponse);
rpc Hijack(HijackRequest) returns (HijackResponse);
}

134
vms/rpcchainvm/ghttp/gresponsewriter/writer_client.go Normal file
View File

@ -0,0 +1,134 @@
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package gresponsewriter
import (
"bufio"
"context"
"net"
"net/http"
"github.com/hashicorp/go-plugin"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gconn"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greader"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gwriter"
connproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gconn/proto"
readerproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greader/proto"
responsewriterproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gresponsewriter/proto"
writerproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gwriter/proto"
)
// Client is an implementation of a messenger channel that talks over RPC.
type Client struct {
client responsewriterproto.WriterClient
header http.Header
broker *plugin.GRPCBroker
}
// NewClient returns a database instance connected to a remote database instance
func NewClient(client responsewriterproto.WriterClient, broker *plugin.GRPCBroker) *Client {
return &Client{
client: client,
header: make(http.Header),
broker: broker,
}
}
// Header ...
func (c *Client) Header() http.Header { return c.header }
// Write ...
func (c *Client) Write(payload []byte) (int, error) {
req := &responsewriterproto.WriteRequest{
Headers: make([]*responsewriterproto.Header, 0, len(c.header)),
Payload: payload,
}
for key, values := range c.header {
req.Headers = append(req.Headers, &responsewriterproto.Header{
Key: key,
Values: values,
})
}
resp, err := c.client.Write(context.Background(), req)
if err != nil {
return 0, err
}
return int(resp.Written), nil
}
// WriteHeader ...
func (c *Client) WriteHeader(statusCode int) {
req := &responsewriterproto.WriteHeaderRequest{
Headers: make([]*responsewriterproto.Header, 0, len(c.header)),
StatusCode: int32(statusCode),
}
for key, values := range c.header {
req.Headers = append(req.Headers, &responsewriterproto.Header{
Key: key,
Values: values,
})
}
// TODO: How should we handle an error here?
c.client.WriteHeader(context.Background(), req)
}
// Flush ...
func (c *Client) Flush() {
// TODO: How should we handle an error here?
c.client.Flush(context.Background(), &responsewriterproto.FlushRequest{})
}
type addr struct {
network string
str string
}
func (a *addr) Network() string { return a.network }
func (a *addr) String() string { return a.str }
// Hijack ...
func (c *Client) Hijack() (net.Conn, *bufio.ReadWriter, error) {
resp, err := c.client.Hijack(context.Background(), &responsewriterproto.HijackRequest{})
if err != nil {
return nil, nil, err
}
connConn, err := c.broker.Dial(resp.ConnServer)
if err != nil {
return nil, nil, err
}
readerConn, err := c.broker.Dial(resp.ReaderServer)
if err != nil {
connConn.Close()
return nil, nil, err
}
writerConn, err := c.broker.Dial(resp.WriterServer)
if err != nil {
connConn.Close()
readerConn.Close()
return nil, nil, err
}
conn := gconn.NewClient(connproto.NewConnClient(connConn), &addr{
network: resp.LocalNetwork,
str: resp.LocalString,
}, &addr{
network: resp.RemoteNetwork,
str: resp.RemoteString,
}, connConn, readerConn, writerConn)
reader := greader.NewClient(readerproto.NewReaderClient(readerConn))
writer := gwriter.NewClient(writerproto.NewWriterClient(writerConn))
readWriter := bufio.NewReadWriter(
bufio.NewReader(reader),
bufio.NewWriter(writer),
)
return conn, readWriter, nil
}

123
vms/rpcchainvm/ghttp/gresponsewriter/writer_server.go Normal file
View File

@ -0,0 +1,123 @@
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package gresponsewriter
import (
"context"
"errors"
"net/http"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gconn"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greader"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gwriter"
"github.com/hashicorp/go-plugin"
"google.golang.org/grpc"
connproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gconn/proto"
readerproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greader/proto"
responsewriterproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gresponsewriter/proto"
writerproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gwriter/proto"
)
// Server is a http.Handler that is managed over RPC.
type Server struct {
writer http.ResponseWriter
broker *plugin.GRPCBroker
}
// NewServer returns a http.Handler instance manage remotely
func NewServer(writer http.ResponseWriter, broker *plugin.GRPCBroker) *Server {
return &Server{
writer: writer,
broker: broker,
}
}
// Write ...
func (s *Server) Write(ctx context.Context, req *responsewriterproto.WriteRequest) (*responsewriterproto.WriteResponse, error) {
headers := s.writer.Header()
for key := range headers {
delete(headers, key)
}
for _, header := range req.Headers {
headers[header.Key] = header.Values
}
n, err := s.writer.Write(req.Payload)
if err != nil {
return nil, err
}
return &responsewriterproto.WriteResponse{
Written: int32(n),
}, nil
}
// WriteHeader ...
func (s *Server) WriteHeader(ctx context.Context, req *responsewriterproto.WriteHeaderRequest) (*responsewriterproto.WriteHeaderResponse, error) {
headers := s.writer.Header()
for key := range headers {
delete(headers, key)
}
for _, header := range req.Headers {
headers[header.Key] = header.Values
}
s.writer.WriteHeader(int(req.StatusCode))
return &responsewriterproto.WriteHeaderResponse{}, nil
}
// Flush ...
func (s *Server) Flush(ctx context.Context, req *responsewriterproto.FlushRequest) (*responsewriterproto.FlushResponse, error) {
flusher, ok := s.writer.(http.Flusher)
if !ok {
return nil, errors.New("response writer doesn't support flushing")
}
flusher.Flush()
return &responsewriterproto.FlushResponse{}, nil
}
// Hijack ...
func (s *Server) Hijack(ctx context.Context, req *responsewriterproto.HijackRequest) (*responsewriterproto.HijackResponse, error) {
hijacker, ok := s.writer.(http.Hijacker)
if !ok {
return nil, errors.New("response writer doesn't support hijacking")
}
conn, readWriter, err := hijacker.Hijack()
if err != nil {
return nil, err
}
connID := s.broker.NextId()
readerID := s.broker.NextId()
writerID := s.broker.NextId()
go s.broker.AcceptAndServe(connID, func(opts []grpc.ServerOption) *grpc.Server {
connServer := grpc.NewServer(opts...)
connproto.RegisterConnServer(connServer, gconn.NewServer(conn))
return connServer
})
go s.broker.AcceptAndServe(readerID, func(opts []grpc.ServerOption) *grpc.Server {
readerServer := grpc.NewServer(opts...)
readerproto.RegisterReaderServer(readerServer, greader.NewServer(readWriter))
return readerServer
})
go s.broker.AcceptAndServe(writerID, func(opts []grpc.ServerOption) *grpc.Server {
writerServer := grpc.NewServer(opts...)
writerproto.RegisterWriterServer(writerServer, gwriter.NewServer(readWriter))
return writerServer
})
local := conn.LocalAddr()
remote := conn.RemoteAddr()
return &responsewriterproto.HijackResponse{
ConnServer: connID,
LocalNetwork: local.Network(),
LocalString: local.String(),
RemoteNetwork: remote.Network(),
RemoteString: remote.String(),
ReaderServer: readerID,
WriterServer: writerID,
}, nil
}

221
vms/rpcchainvm/ghttp/gwriter/proto/writer.pb.go Normal file
View File

@ -0,0 +1,221 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: writer.proto
package proto
import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type WriteRequest struct {
Payload []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WriteRequest) Reset() { *m = WriteRequest{} }
func (m *WriteRequest) String() string { return proto.CompactTextString(m) }
func (*WriteRequest) ProtoMessage() {}
func (*WriteRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ea6fbe89c42e6759, []int{0}
}
func (m *WriteRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_WriteRequest.Unmarshal(m, b)
}
func (m *WriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WriteRequest.Marshal(b, m, deterministic)
}
func (m *WriteRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_WriteRequest.Merge(m, src)
}
func (m *WriteRequest) XXX_Size() int {
return xxx_messageInfo_WriteRequest.Size(m)
}
func (m *WriteRequest) XXX_DiscardUnknown() {
xxx_messageInfo_WriteRequest.DiscardUnknown(m)
}
var xxx_messageInfo_WriteRequest proto.InternalMessageInfo
func (m *WriteRequest) GetPayload() []byte {
if m != nil {
return m.Payload
}
return nil
}
type WriteResponse struct {
Written int32 `protobuf:"varint,1,opt,name=written,proto3" json:"written,omitempty"`
Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
Errored bool `protobuf:"varint,3,opt,name=errored,proto3" json:"errored,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WriteResponse) Reset() { *m = WriteResponse{} }
func (m *WriteResponse) String() string { return proto.CompactTextString(m) }
func (*WriteResponse) ProtoMessage() {}
func (*WriteResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ea6fbe89c42e6759, []int{1}
}
func (m *WriteResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_WriteResponse.Unmarshal(m, b)
}
func (m *WriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WriteResponse.Marshal(b, m, deterministic)
}
func (m *WriteResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_WriteResponse.Merge(m, src)
}
func (m *WriteResponse) XXX_Size() int {
return xxx_messageInfo_WriteResponse.Size(m)
}
func (m *WriteResponse) XXX_DiscardUnknown() {
xxx_messageInfo_WriteResponse.DiscardUnknown(m)
}
var xxx_messageInfo_WriteResponse proto.InternalMessageInfo
func (m *WriteResponse) GetWritten() int32 {
if m != nil {
return m.Written
}
return 0
}
func (m *WriteResponse) GetError() string {
if m != nil {
return m.Error
}
return ""
}
func (m *WriteResponse) GetErrored() bool {
if m != nil {
return m.Errored
}
return false
}
func init() {
proto.RegisterType((*WriteRequest)(nil), "proto.WriteRequest")
proto.RegisterType((*WriteResponse)(nil), "proto.WriteResponse")
}
func init() { proto.RegisterFile("writer.proto", fileDescriptor_ea6fbe89c42e6759) }
var fileDescriptor_ea6fbe89c42e6759 = []byte{
// 164 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x2f, 0xca, 0x2c,
0x49, 0x2d, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x05, 0x53, 0x4a, 0x1a, 0x5c, 0x3c,
0xe1, 0x20, 0xe1, 0xa0, 0xd4, 0xc2, 0xd2, 0xd4, 0xe2, 0x12, 0x21, 0x09, 0x2e, 0xf6, 0x82, 0xc4,
0xca, 0x9c, 0xfc, 0xc4, 0x14, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x9e, 0x20, 0x18, 0x57, 0x29, 0x92,
0x8b, 0x17, 0xaa, 0xb2, 0xb8, 0x20, 0x3f, 0xaf, 0x38, 0x15, 0xa4, 0x14, 0x64, 0x62, 0x49, 0x6a,
0x1e, 0x58, 0x29, 0x6b, 0x10, 0x8c, 0x2b, 0x24, 0xc2, 0xc5, 0x9a, 0x5a, 0x54, 0x94, 0x5f, 0x24,
0xc1, 0xa4, 0xc0, 0xa8, 0xc1, 0x19, 0x04, 0xe1, 0x80, 0xd4, 0x83, 0x19, 0xa9, 0x29, 0x12, 0xcc,
0x0a, 0x8c, 0x1a, 0x1c, 0x41, 0x30, 0xae, 0x91, 0x0d, 0x17, 0x1b, 0xd8, 0xe8, 0x22, 0x21, 0x23,
0x2e, 0x56, 0x30, 0x4b, 0x48, 0x18, 0xe2, 0x4c, 0x3d, 0x64, 0xc7, 0x49, 0x89, 0xa0, 0x0a, 0x42,
0xdc, 0x91, 0xc4, 0x06, 0x16, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x3e, 0x3f, 0xbb, 0x2f,
0xe0, 0x00, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// WriterClient is the client API for Writer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type WriterClient interface {
Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*WriteResponse, error)
}
type writerClient struct {
cc grpc.ClientConnInterface
}
func NewWriterClient(cc grpc.ClientConnInterface) WriterClient {
return &writerClient{cc}
}
func (c *writerClient) Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*WriteResponse, error) {
out := new(WriteResponse)
err := c.cc.Invoke(ctx, "/proto.Writer/Write", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// WriterServer is the server API for Writer service.
type WriterServer interface {
Write(context.Context, *WriteRequest) (*WriteResponse, error)
}
// UnimplementedWriterServer can be embedded to have forward compatible implementations.
type UnimplementedWriterServer struct {
}
func (*UnimplementedWriterServer) Write(ctx context.Context, req *WriteRequest) (*WriteResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Write not implemented")
}
func RegisterWriterServer(s *grpc.Server, srv WriterServer) {
s.RegisterService(&_Writer_serviceDesc, srv)
}
func _Writer_Write_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WriteRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WriterServer).Write(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/proto.Writer/Write",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WriterServer).Write(ctx, req.(*WriteRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Writer_serviceDesc = grpc.ServiceDesc{
ServiceName: "proto.Writer",
HandlerType: (*WriterServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Write",
Handler: _Writer_Write_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "writer.proto",
}

16
vms/rpcchainvm/ghttp/gwriter/proto/writer.proto Normal file
View File

@ -0,0 +1,16 @@
syntax = "proto3";
package proto;
message WriteRequest {
bytes payload = 1;
}
message WriteResponse {
int32 written = 1;
string error = 2;
bool errored = 3;
}
service Writer {
rpc Write(WriteRequest) returns (WriteResponse);
}

34
vms/rpcchainvm/ghttp/gwriter/writer_client.go Normal file
View File

@ -0,0 +1,34 @@
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package gwriter
import (
"context"
"errors"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gwriter/proto"
)
// Client is an implementation of a messenger channel that talks over RPC.
type Client struct{ client proto.WriterClient }
// NewClient returns a database instance connected to a remote database instance
func NewClient(client proto.WriterClient) *Client {
return &Client{client: client}
}
// Write ...
func (c *Client) Write(p []byte) (int, error) {
resp, err := c.client.Write(context.Background(), &proto.WriteRequest{
Payload: p,
})
if err != nil {
return 0, err
}
if resp.Errored {
err = errors.New(resp.Error)
}
return int(resp.Written), err
}

32
vms/rpcchainvm/ghttp/gwriter/writer_server.go Normal file
View File

@ -0,0 +1,32 @@
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package gwriter
import (
"context"
"io"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gwriter/proto"
)
// Server is a http.Handler that is managed over RPC.
type Server struct{ writer io.Writer }
// NewServer returns a http.Handler instance manage remotely
func NewServer(writer io.Writer) *Server {
return &Server{writer: writer}
}
// Write ...
func (s *Server) Write(ctx context.Context, req *proto.WriteRequest) (*proto.WriteResponse, error) {
n, err := s.writer.Write(req.Payload)
resp := &proto.WriteResponse{
Written: int32(n),
}
if err != nil {
resp.Errored = true
resp.Error = err.Error()
}
return resp, nil
}

152
vms/rpcchainvm/ghttp/http_client.go
View File

@ -4,61 +4,149 @@
package ghttp
import (
"io/ioutil"
"net/http"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/proto"
"google.golang.org/grpc"
"github.com/hashicorp/go-plugin"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greadcloser"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gresponsewriter"
readcloserproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greadcloser/proto"
responsewriterproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gresponsewriter/proto"
httpproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/proto"
)
// Client is an implementation of a messenger channel that talks over RPC.
type Client struct{ client proto.HTTPClient }
type Client struct {
client httpproto.HTTPClient
broker *plugin.GRPCBroker
}
// NewClient returns a database instance connected to a remote database instance
func NewClient(client proto.HTTPClient) *Client {
return &Client{client: client}
func NewClient(client httpproto.HTTPClient, broker *plugin.GRPCBroker) *Client {
return &Client{
client: client,
broker: broker,
}
}
// Handle ...
func (c *Client) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// get the headers
inboundHeaders := make([]*proto.Header, len(r.Header))[:0]
var reader *grpc.Server
var writer *grpc.Server
readerID := c.broker.NextId()
go c.broker.AcceptAndServe(readerID, func(opts []grpc.ServerOption) *grpc.Server {
reader = grpc.NewServer(opts...)
readcloserproto.RegisterReaderServer(reader, greadcloser.NewServer(r.Body))
return reader
})
writerID := c.broker.NextId()
go c.broker.AcceptAndServe(writerID, func(opts []grpc.ServerOption) *grpc.Server {
writer = grpc.NewServer(opts...)
responsewriterproto.RegisterWriterServer(writer, gresponsewriter.NewServer(w, c.broker))
return writer
})
req := &httpproto.HTTPRequest{
ResponseWriter: writerID,
Request: &httpproto.Request{
Method: r.Method,
Proto: r.Proto,
ProtoMajor: int32(r.ProtoMajor),
ProtoMinor: int32(r.ProtoMinor),
Body: readerID,
ContentLength: r.ContentLength,
TransferEncoding: r.TransferEncoding,
Host: r.Host,
RemoteAddr: r.RemoteAddr,
RequestURI: r.RequestURI,
},
}
req.Request.Header = make([]*httpproto.Element, 0, len(r.Header))
for key, values := range r.Header {
inboundHeaders = append(inboundHeaders, &proto.Header{
req.Request.Header = append(req.Request.Header, &httpproto.Element{
Key: key,
Values: values,
})
}
// get the body
body, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
req.Request.Form = make([]*httpproto.Element, 0, len(r.Form))
for key, values := range r.Form {
req.Request.Form = append(req.Request.Form, &httpproto.Element{
Key: key,
Values: values,
})
}
// execute the call
resp, err := c.client.Handle(r.Context(), &proto.HTTPRequest{
Url: r.RequestURI,
Method: r.Method,
Headers: inboundHeaders,
Body: body,
})
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
req.Request.PostForm = make([]*httpproto.Element, 0, len(r.PostForm))
for key, values := range r.PostForm {
req.Request.PostForm = append(req.Request.PostForm, &httpproto.Element{
Key: key,
Values: values,
})
}
// return the code
w.WriteHeader(int(resp.Code))
if r.URL != nil {
req.Request.Url = &httpproto.URL{
Scheme: r.URL.Scheme,
Opaque: r.URL.Opaque,
Host: r.URL.Host,
Path: r.URL.Path,
RawPath: r.URL.RawPath,
ForceQuery: r.URL.ForceQuery,
RawQuery: r.URL.RawQuery,
Fragment: r.URL.Fragment,
}
// return the headers
outboundHeaders := w.Header()
for _, header := range resp.Headers {
outboundHeaders[header.Key] = header.Values
if r.URL.User != nil {
req.Request.Url.User = &httpproto.Userinfo{
Username: r.URL.User.Username(),
}
pwd, set := r.URL.User.Password()
req.Request.Url.User.Password = pwd
req.Request.Url.User.PasswordSet = set
}
}
// return the body
if _, err := w.Write(resp.Body); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
if r.TLS != nil {
req.Request.Tls = &httpproto.ConnectionState{
Version: uint32(r.TLS.Version),
HandshakeComplete: r.TLS.HandshakeComplete,
DidResume: r.TLS.DidResume,
CipherSuite: uint32(r.TLS.CipherSuite),
NegotiatedProtocol: r.TLS.NegotiatedProtocol,
NegotiatedProtocolIsMutual: r.TLS.NegotiatedProtocolIsMutual,
ServerName: r.TLS.ServerName,
SignedCertificateTimestamps: r.TLS.SignedCertificateTimestamps,
OcspResponse: r.TLS.OCSPResponse,
TlsUnique: r.TLS.TLSUnique,
}
req.Request.Tls.PeerCertificates = &httpproto.Certificates{
Cert: make([][]byte, len(r.TLS.PeerCertificates)),
}
for i, cert := range r.TLS.PeerCertificates {
req.Request.Tls.PeerCertificates.Cert[i] = cert.Raw
}
req.Request.Tls.VerifiedChains = make([]*httpproto.Certificates, len(r.TLS.VerifiedChains))
for i, chain := range r.TLS.VerifiedChains {
req.Request.Tls.VerifiedChains[i] = &httpproto.Certificates{
Cert: make([][]byte, len(chain)),
}
for j, cert := range chain {
req.Request.Tls.VerifiedChains[i].Cert[j] = cert.Raw
}
}
}
c.client.Handle(r.Context(), req)
reader.Stop()
writer.Stop()
}

149
vms/rpcchainvm/ghttp/http_server.go
View File

@ -4,59 +4,144 @@
package ghttp
import (
"bytes"
"context"
"io/ioutil"
"crypto/tls"
"crypto/x509"
"net/http"
"net/http/httptest"
"net/url"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/proto"
"github.com/hashicorp/go-plugin"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greadcloser"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gresponsewriter"
readcloserproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/greadcloser/proto"
responsewriterproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/gresponsewriter/proto"
httpproto "github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/proto"
)
// Server is a http.Handler that is managed over RPC.
type Server struct{ handler http.Handler }
type Server struct {
handler http.Handler
broker *plugin.GRPCBroker
}
// NewServer returns a http.Handler instance manage remotely
func NewServer(handler http.Handler) *Server {
return &Server{handler: handler}
func NewServer(handler http.Handler, broker *plugin.GRPCBroker) *Server {
return &Server{
handler: handler,
broker: broker,
}
}
// Handle ...
func (s Server) Handle(ctx context.Context, req *proto.HTTPRequest) (*proto.HTTPResponse, error) {
func (s *Server) Handle(ctx context.Context, req *httpproto.HTTPRequest) (*httpproto.HTTPResponse, error) {
writerConn, err := s.broker.Dial(req.ResponseWriter)
if err != nil {
return nil, err
}
defer writerConn.Close()
readerConn, err := s.broker.Dial(req.Request.Body)
if err != nil {
return nil, err
}
defer readerConn.Close()
writer := gresponsewriter.NewClient(responsewriterproto.NewWriterClient(writerConn), s.broker)
reader := greadcloser.NewClient(readcloserproto.NewReaderClient(readerConn))
// create the request with the current context
r, err := http.NewRequestWithContext(
request, err := http.NewRequestWithContext(
ctx,
req.Method,
req.Url,
ioutil.NopCloser(bytes.NewReader(req.Body)),
req.Request.Method,
req.Request.RequestURI,
reader,
)
if err != nil {
return nil, err
}
// populate the headers
for _, header := range req.Headers {
r.Header[header.Key] = header.Values
if req.Request.Url != nil {
request.URL = &url.URL{
Scheme: req.Request.Url.Scheme,
Opaque: req.Request.Url.Opaque,
Host: req.Request.Url.Host,
Path: req.Request.Url.Path,
RawPath: req.Request.Url.RawPath,
ForceQuery: req.Request.Url.ForceQuery,
RawQuery: req.Request.Url.RawQuery,
Fragment: req.Request.Url.Fragment,
}
if req.Request.Url.User != nil {
if req.Request.Url.User.PasswordSet {
request.URL.User = url.UserPassword(req.Request.Url.User.Username, req.Request.Url.User.Password)
} else {
request.URL.User = url.User(req.Request.Url.User.Username)
}
}
}
// send the request to the recorder
recorder := httptest.NewRecorder()
s.handler.ServeHTTP(recorder, r)
// get the returned headers
returnedHeaders := recorder.Header()
headers := make([]*proto.Header, len(returnedHeaders))[:0]
for key, values := range returnedHeaders {
headers = append(headers, &proto.Header{
Key: key,
Values: values,
})
request.Proto = req.Request.Proto
request.ProtoMajor = int(req.Request.ProtoMajor)
request.ProtoMinor = int(req.Request.ProtoMinor)
request.Header = make(http.Header, len(req.Request.Header))
for _, elem := range req.Request.Header {
request.Header[elem.Key] = elem.Values
}
request.ContentLength = req.Request.ContentLength
request.TransferEncoding = req.Request.TransferEncoding
request.Host = req.Request.Host
request.Form = make(url.Values, len(req.Request.Form))
for _, elem := range req.Request.Form {
request.Form[elem.Key] = elem.Values
}
request.PostForm = make(url.Values, len(req.Request.PostForm))
for _, elem := range req.Request.PostForm {
request.PostForm[elem.Key] = elem.Values
}
request.Trailer = make(http.Header)
request.RemoteAddr = req.Request.RemoteAddr
request.RequestURI = req.Request.RequestURI
if req.Request.Tls != nil {
request.TLS = &tls.ConnectionState{
Version: uint16(req.Request.Tls.Version),
HandshakeComplete: req.Request.Tls.HandshakeComplete,
DidResume: req.Request.Tls.DidResume,
CipherSuite: uint16(req.Request.Tls.CipherSuite),
NegotiatedProtocol: req.Request.Tls.NegotiatedProtocol,
NegotiatedProtocolIsMutual: req.Request.Tls.NegotiatedProtocolIsMutual,
ServerName: req.Request.Tls.ServerName,
SignedCertificateTimestamps: req.Request.Tls.SignedCertificateTimestamps,
OCSPResponse: req.Request.Tls.OcspResponse,
TLSUnique: req.Request.Tls.TlsUnique,
}
request.TLS.PeerCertificates = make([]*x509.Certificate, len(req.Request.Tls.PeerCertificates.Cert))
for i, certBytes := range req.Request.Tls.PeerCertificates.Cert {
cert, err := x509.ParseCertificate(certBytes)
if err != nil {
return nil, err
}
request.TLS.PeerCertificates[i] = cert
}
request.TLS.VerifiedChains = make([][]*x509.Certificate, len(req.Request.Tls.VerifiedChains))
for i, chain := range req.Request.Tls.VerifiedChains {
request.TLS.VerifiedChains[i] = make([]*x509.Certificate, len(chain.Cert))
for j, certBytes := range chain.Cert {
cert, err := x509.ParseCertificate(certBytes)
if err != nil {
return nil, err
}
request.TLS.VerifiedChains[i][j] = cert
}
}
}
s.handler.ServeHTTP(writer, request)
// return the response
return &proto.HTTPResponse{
Code: int32(recorder.Code),
Headers: headers,
Body: recorder.Body.Bytes(),
}, nil
return &httpproto.HTTPResponse{}, nil
}

96
vms/rpcchainvm/ghttp/http_test.go
View File

@ -1,96 +0,0 @@
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package ghttp
import (
"bytes"
"log"
"net"
"net/http"
"net/http/httptest"
"testing"
"golang.org/x/net/context"
"google.golang.org/grpc"
"google.golang.org/grpc/test/bufconn"
"github.com/gorilla/rpc/v2"
"github.com/gorilla/rpc/v2/json2"
"github.com/ava-labs/gecko/utils/json"
"github.com/ava-labs/gecko/vms/rpcchainvm/ghttp/proto"
)
const (
bufSize = 1 << 20
)
type service struct{}
type Args struct{}
type Reply struct {
Called bool
}
func (s *service) Call(r *http.Request, args *Args, reply *Reply) error {
reply.Called = true
return nil
}
func TestRPC(t *testing.T) {
rpcServer := rpc.NewServer()
codec := json.NewCodec()
rpcServer.RegisterCodec(codec, "application/json")
rpcServer.RegisterCodec(codec, "application/json;charset=UTF-8")
rpcServer.RegisterService(&service{}, "service")
listener := bufconn.Listen(bufSize)
server := grpc.NewServer()
proto.RegisterHTTPServer(server, NewServer(rpcServer))
go func() {
if err := server.Serve(listener); err != nil {
log.Fatal(err)
}
}()
dialer := grpc.WithContextDialer(
func(context.Context, string) (net.Conn, error) {
return listener.Dial()
})
ctx := context.Background()
conn, err := grpc.DialContext(ctx, "", dialer, grpc.WithInsecure())
if err != nil {
t.Fatal(err)
}
defer conn.Close()
rpcClient := NewClient(proto.NewHTTPClient(conn))
req := &Args{}
buf, err := json2.EncodeClientRequest("service.call", req)
if err != nil {
t.Fatal(err)
}
body := bytes.NewBuffer(buf)
r, err := http.NewRequest("POST", "http://localhost:8080/", body)
if err != nil {
t.Fatal(err)
}
r.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
rpcClient.ServeHTTP(w, r)
res := &Reply{}
if err := json2.DecodeClientResponse(w.Body, res); err != nil {
t.Fatal(err)
}
if !res.Called {
t.Fatalf("Should have called the function")
}
}

666
vms/rpcchainvm/ghttp/proto/http.pb.go
View File

@ -24,7 +24,165 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type Header struct {
type Userinfo struct {
Username string `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
PasswordSet bool `protobuf:"varint,3,opt,name=passwordSet,proto3" json:"passwordSet,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Userinfo) Reset() { *m = Userinfo{} }
func (m *Userinfo) String() string { return proto.CompactTextString(m) }
func (*Userinfo) ProtoMessage() {}
func (*Userinfo) Descriptor() ([]byte, []int) {
return fileDescriptor_11b04836674e6f94, []int{0}
}
func (m *Userinfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Userinfo.Unmarshal(m, b)
}
func (m *Userinfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Userinfo.Marshal(b, m, deterministic)
}
func (m *Userinfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_Userinfo.Merge(m, src)
}
func (m *Userinfo) XXX_Size() int {
return xxx_messageInfo_Userinfo.Size(m)
}
func (m *Userinfo) XXX_DiscardUnknown() {
xxx_messageInfo_Userinfo.DiscardUnknown(m)
}
var xxx_messageInfo_Userinfo proto.InternalMessageInfo
func (m *Userinfo) GetUsername() string {
if m != nil {
return m.Username
}
return ""
}
func (m *Userinfo) GetPassword() string {
if m != nil {
return m.Password
}
return ""
}
func (m *Userinfo) GetPasswordSet() bool {
if m != nil {
return m.PasswordSet
}
return false
}
type URL struct {
Scheme string `protobuf:"bytes,1,opt,name=scheme,proto3" json:"scheme,omitempty"`
Opaque string `protobuf:"bytes,2,opt,name=opaque,proto3" json:"opaque,omitempty"`
User *Userinfo `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
Host string `protobuf:"bytes,4,opt,name=host,proto3" json:"host,omitempty"`
Path string `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
RawPath string `protobuf:"bytes,6,opt,name=rawPath,proto3" json:"rawPath,omitempty"`
ForceQuery bool `protobuf:"varint,7,opt,name=forceQuery,proto3" json:"forceQuery,omitempty"`
RawQuery string `protobuf:"bytes,8,opt,name=rawQuery,proto3" json:"rawQuery,omitempty"`
Fragment string `protobuf:"bytes,9,opt,name=fragment,proto3" json:"fragment,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *URL) Reset() { *m = URL{} }
func (m *URL) String() string { return proto.CompactTextString(m) }
func (*URL) ProtoMessage() {}
func (*URL) Descriptor() ([]byte, []int) {
return fileDescriptor_11b04836674e6f94, []int{1}
}
func (m *URL) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_URL.Unmarshal(m, b)
}
func (m *URL) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_URL.Marshal(b, m, deterministic)
}
func (m *URL) XXX_Merge(src proto.Message) {
xxx_messageInfo_URL.Merge(m, src)
}
func (m *URL) XXX_Size() int {
return xxx_messageInfo_URL.Size(m)
}
func (m *URL) XXX_DiscardUnknown() {
xxx_messageInfo_URL.DiscardUnknown(m)
}
var xxx_messageInfo_URL proto.InternalMessageInfo
func (m *URL) GetScheme() string {
if m != nil {
return m.Scheme
}
return ""
}
func (m *URL) GetOpaque() string {
if m != nil {
return m.Opaque
}
return ""
}
func (m *URL) GetUser() *Userinfo {
if m != nil {
return m.User
}
return nil
}
func (m *URL) GetHost() string {
if m != nil {
return m.Host
}
return ""
}
func (m *URL) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func (m *URL) GetRawPath() string {
if m != nil {
return m.RawPath
}
return ""
}
func (m *URL) GetForceQuery() bool {
if m != nil {
return m.ForceQuery
}
return false
}
func (m *URL) GetRawQuery() string {
if m != nil {
return m.RawQuery
}
return ""
}
func (m *URL) GetFragment() string {
if m != nil {
return m.Fragment
}
return ""
}
type Element struct {
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
Values []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -32,60 +190,383 @@ type Header struct {
XXX_sizecache int32 `json:"-"`
}
func (m *Header) Reset() { *m = Header{} }
func (m *Header) String() string { return proto.CompactTextString(m) }
func (*Header) ProtoMessage() {}
func (*Header) Descriptor() ([]byte, []int) {
return fileDescriptor_11b04836674e6f94, []int{0}
func (m *Element) Reset() { *m = Element{} }
func (m *Element) String() string { return proto.CompactTextString(m) }
func (*Element) ProtoMessage() {}
func (*Element) Descriptor() ([]byte, []int) {
return fileDescriptor_11b04836674e6f94, []int{2}
}
func (m *Header) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Header.Unmarshal(m, b)
func (m *Element) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Element.Unmarshal(m, b)
}
func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Header.Marshal(b, m, deterministic)
func (m *Element) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Element.Marshal(b, m, deterministic)
}
func (m *Header) XXX_Merge(src proto.Message) {
xxx_messageInfo_Header.Merge(m, src)
func (m *Element) XXX_Merge(src proto.Message) {
xxx_messageInfo_Element.Merge(m, src)
}
func (m *Header) XXX_Size() int {
return xxx_messageInfo_Header.Size(m)
func (m *Element) XXX_Size() int {
return xxx_messageInfo_Element.Size(m)
}
func (m *Header) XXX_DiscardUnknown() {
xxx_messageInfo_Header.DiscardUnknown(m)
func (m *Element) XXX_DiscardUnknown() {
xxx_messageInfo_Element.DiscardUnknown(m)
}
var xxx_messageInfo_Header proto.InternalMessageInfo
var xxx_messageInfo_Element proto.InternalMessageInfo
func (m *Header) GetKey() string {
func (m *Element) GetKey() string {
if m != nil {
return m.Key
}
return ""
}
func (m *Header) GetValues() []string {
func (m *Element) GetValues() []string {
if m != nil {
return m.Values
}
return nil
}
type Certificates struct {
Cert [][]byte `protobuf:"bytes,1,rep,name=cert,proto3" json:"cert,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Certificates) Reset() { *m = Certificates{} }
func (m *Certificates) String() string { return proto.CompactTextString(m) }
func (*Certificates) ProtoMessage() {}
func (*Certificates) Descriptor() ([]byte, []int) {
return fileDescriptor_11b04836674e6f94, []int{3}
}
func (m *Certificates) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Certificates.Unmarshal(m, b)
}
func (m *Certificates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Certificates.Marshal(b, m, deterministic)
}
func (m *Certificates) XXX_Merge(src proto.Message) {
xxx_messageInfo_Certificates.Merge(m, src)
}
func (m *Certificates) XXX_Size() int {
return xxx_messageInfo_Certificates.Size(m)
}
func (m *Certificates) XXX_DiscardUnknown() {
xxx_messageInfo_Certificates.DiscardUnknown(m)
}
var xxx_messageInfo_Certificates proto.InternalMessageInfo
func (m *Certificates) GetCert() [][]byte {
if m != nil {
return m.Cert
}
return nil
}
type ConnectionState struct {
Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
HandshakeComplete bool `protobuf:"varint,2,opt,name=handshakeComplete,proto3" json:"handshakeComplete,omitempty"`
DidResume bool `protobuf:"varint,3,opt,name=didResume,proto3" json:"didResume,omitempty"`
CipherSuite uint32 `protobuf:"varint,4,opt,name=cipherSuite,proto3" json:"cipherSuite,omitempty"`
NegotiatedProtocol string `protobuf:"bytes,5,opt,name=negotiatedProtocol,proto3" json:"negotiatedProtocol,omitempty"`
NegotiatedProtocolIsMutual bool `protobuf:"varint,6,opt,name=negotiatedProtocolIsMutual,proto3" json:"negotiatedProtocolIsMutual,omitempty"`
ServerName string `protobuf:"bytes,7,opt,name=serverName,proto3" json:"serverName,omitempty"`
PeerCertificates *Certificates `protobuf:"bytes,8,opt,name=peerCertificates,proto3" json:"peerCertificates,omitempty"`
VerifiedChains []*Certificates `protobuf:"bytes,9,rep,name=verifiedChains,proto3" json:"verifiedChains,omitempty"`
SignedCertificateTimestamps [][]byte `protobuf:"bytes,10,rep,name=signedCertificateTimestamps,proto3" json:"signedCertificateTimestamps,omitempty"`
OcspResponse []byte `protobuf:"bytes,11,opt,name=ocspResponse,proto3" json:"ocspResponse,omitempty"`
TlsUnique []byte `protobuf:"bytes,12,opt,name=tlsUnique,proto3" json:"tlsUnique,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ConnectionState) Reset() { *m = ConnectionState{} }
func (m *ConnectionState) String() string { return proto.CompactTextString(m) }
func (*ConnectionState) ProtoMessage() {}
func (*ConnectionState) Descriptor() ([]byte, []int) {
return fileDescriptor_11b04836674e6f94, []int{4}
}
func (m *ConnectionState) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ConnectionState.Unmarshal(m, b)
}
func (m *ConnectionState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ConnectionState.Marshal(b, m, deterministic)
}
func (m *ConnectionState) XXX_Merge(src proto.Message) {
xxx_messageInfo_ConnectionState.Merge(m, src)
}
func (m *ConnectionState) XXX_Size() int {
return xxx_messageInfo_ConnectionState.Size(m)
}
func (m *ConnectionState) XXX_DiscardUnknown() {
xxx_messageInfo_ConnectionState.DiscardUnknown(m)
}
var xxx_messageInfo_ConnectionState proto.InternalMessageInfo
func (m *ConnectionState) GetVersion() uint32 {
if m != nil {
return m.Version
}
return 0
}
func (m *ConnectionState) GetHandshakeComplete() bool {
if m != nil {
return m.HandshakeComplete
}
return false
}
func (m *ConnectionState) GetDidResume() bool {
if m != nil {
return m.DidResume
}
return false
}
func (m *ConnectionState) GetCipherSuite() uint32 {
if m != nil {
return m.CipherSuite
}
return 0
}
func (m *ConnectionState) GetNegotiatedProtocol() string {
if m != nil {
return m.NegotiatedProtocol
}
return ""
}
func (m *ConnectionState) GetNegotiatedProtocolIsMutual() bool {
if m != nil {
return m.NegotiatedProtocolIsMutual
}
return false
}
func (m *ConnectionState) GetServerName() string {
if m != nil {
return m.ServerName
}
return ""
}
func (m *ConnectionState) GetPeerCertificates() *Certificates {
if m != nil {
return m.PeerCertificates
}
return nil
}
func (m *ConnectionState) GetVerifiedChains() []*Certificates {
if m != nil {
return m.VerifiedChains
}
return nil
}
func (m *ConnectionState) GetSignedCertificateTimestamps() [][]byte {
if m != nil {
return m.SignedCertificateTimestamps
}
return nil
}
func (m *ConnectionState) GetOcspResponse() []byte {
if m != nil {
return m.OcspResponse
}
return nil
}
func (m *ConnectionState) GetTlsUnique() []byte {
if m != nil {
return m.TlsUnique
}
return nil
}
type Request struct {
Method string `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
Url *URL `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
Proto string `protobuf:"bytes,3,opt,name=proto,proto3" json:"proto,omitempty"`
ProtoMajor int32 `protobuf:"varint,4,opt,name=protoMajor,proto3" json:"protoMajor,omitempty"`
ProtoMinor int32 `protobuf:"varint,5,opt,name=protoMinor,proto3" json:"protoMinor,omitempty"`
Header []*Element `protobuf:"bytes,6,rep,name=header,proto3" json:"header,omitempty"`
Body uint32 `protobuf:"varint,7,opt,name=body,proto3" json:"body,omitempty"`
ContentLength int64 `protobuf:"varint,8,opt,name=contentLength,proto3" json:"contentLength,omitempty"`
TransferEncoding []string `protobuf:"bytes,9,rep,name=transferEncoding,proto3" json:"transferEncoding,omitempty"`
Host string `protobuf:"bytes,10,opt,name=host,proto3" json:"host,omitempty"`
Form []*Element `protobuf:"bytes,11,rep,name=form,proto3" json:"form,omitempty"`
PostForm []*Element `protobuf:"bytes,12,rep,name=postForm,proto3" json:"postForm,omitempty"`
TrailerKeys []string `protobuf:"bytes,13,rep,name=trailerKeys,proto3" json:"trailerKeys,omitempty"`
RemoteAddr string `protobuf:"bytes,14,opt,name=remoteAddr,proto3" json:"remoteAddr,omitempty"`
RequestURI string `protobuf:"bytes,15,opt,name=requestURI,proto3" json:"requestURI,omitempty"`
Tls *ConnectionState `protobuf:"bytes,16,opt,name=tls,proto3" json:"tls,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Request) Reset() { *m = Request{} }
func (m *Request) String() string { return proto.CompactTextString(m) }
func (*Request) ProtoMessage() {}
func (*Request) Descriptor() ([]byte, []int) {
return fileDescriptor_11b04836674e6f94, []int{5}
}
func (m *Request) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Request.Unmarshal(m, b)
}
func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Request.Marshal(b, m, deterministic)
}
func (m *Request) XXX_Merge(src proto.Message) {
xxx_messageInfo_Request.Merge(m, src)
}
func (m *Request) XXX_Size() int {
return xxx_messageInfo_Request.Size(m)
}
func (m *Request) XXX_DiscardUnknown() {
xxx_messageInfo_Request.DiscardUnknown(m)
}
var xxx_messageInfo_Request proto.InternalMessageInfo
func (m *Request) GetMethod() string {
if m != nil {
return m.Method
}
return ""
}
func (m *Request) GetUrl() *URL {
if m != nil {
return m.Url
}
return nil
}
func (m *Request) GetProto() string {
if m != nil {
return m.Proto
}
return ""
}
func (m *Request) GetProtoMajor() int32 {
if m != nil {
return m.ProtoMajor
}
return 0
}
func (m *Request) GetProtoMinor() int32 {
if m != nil {
return m.ProtoMinor
}
return 0
}
func (m *Request) GetHeader() []*Element {
if m != nil {
return m.Header
}
return nil
}
func (m *Request) GetBody() uint32 {
if m != nil {
return m.Body
}
return 0
}
func (m *Request) GetContentLength() int64 {
if m != nil {
return m.ContentLength
}
return 0
}
func (m *Request) GetTransferEncoding() []string {
if m != nil {
return m.TransferEncoding
}
return nil
}
func (m *Request) GetHost() string {
if m != nil {
return m.Host
}
return ""
}
func (m *Request) GetForm() []*Element {
if m != nil {
return m.Form
}
return nil
}
func (m *Request) GetPostForm() []*Element {
if m != nil {
return m.PostForm
}
return nil
}
func (m *Request) GetTrailerKeys() []string {
if m != nil {
return m.TrailerKeys
}
return nil
}
func (m *Request) GetRemoteAddr() string {
if m != nil {
return m.RemoteAddr
}
return ""
}
func (m *Request) GetRequestURI() string {
if m != nil {
return m.RequestURI
}
return ""
}
func (m *Request) GetTls() *ConnectionState {
if m != nil {
return m.Tls
}
return nil
}
type HTTPRequest struct {
Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
Method string `protobuf:"bytes,2,opt,name=method,proto3" json:"method,omitempty"`
Headers []*Header `protobuf:"bytes,3,rep,name=headers,proto3" json:"headers,omitempty"`
Body []byte `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
ResponseWriter uint32 `protobuf:"varint,1,opt,name=responseWriter,proto3" json:"responseWriter,omitempty"`
Request *Request `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *HTTPRequest) Reset() { *m = HTTPRequest{} }
func (m *HTTPRequest) String() string { return proto.CompactTextString(m) }
func (*HTTPRequest) ProtoMessage() {}
func (*HTTPRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_11b04836674e6f94, []int{1}
return fileDescriptor_11b04836674e6f94, []int{6}
}
func (m *HTTPRequest) XXX_Unmarshal(b []byte) error {
@ -106,48 +587,31 @@ func (m *HTTPRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_HTTPRequest proto.InternalMessageInfo
func (m *HTTPRequest) GetUrl() string {
func (m *HTTPRequest) GetResponseWriter() uint32 {
if m != nil {
return m.Url
return m.ResponseWriter
}
return ""
return 0
}
func (m *HTTPRequest) GetMethod() string {
func (m *HTTPRequest) GetRequest() *Request {
if m != nil {
return m.Method
}
return ""
}
func (m *HTTPRequest) GetHeaders() []*Header {
if m != nil {
return m.Headers
}
return nil
}
func (m *HTTPRequest) GetBody() []byte {
if m != nil {
return m.Body
return m.Request
}
return nil
}
type HTTPResponse struct {
Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
Headers []*Header `protobuf:"bytes,2,rep,name=headers,proto3" json:"headers,omitempty"`
Body []byte `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *HTTPResponse) Reset() { *m = HTTPResponse{} }
func (m *HTTPResponse) String() string { return proto.CompactTextString(m) }
func (*HTTPResponse) ProtoMessage() {}
func (*HTTPResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_11b04836674e6f94, []int{2}
return fileDescriptor_11b04836674e6f94, []int{7}
}
func (m *HTTPResponse) XXX_Unmarshal(b []byte) error {
@ -168,29 +632,13 @@ func (m *HTTPResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_HTTPResponse proto.InternalMessageInfo
func (m *HTTPResponse) GetCode() int32 {
if m != nil {
return m.Code
}
return 0
}
func (m *HTTPResponse) GetHeaders() []*Header {
if m != nil {
return m.Headers
}
return nil
}
func (m *HTTPResponse) GetBody() []byte {
if m != nil {
return m.Body
}
return nil
}
func init() {
proto.RegisterType((*Header)(nil), "proto.Header")
proto.RegisterType((*Userinfo)(nil), "proto.Userinfo")
proto.RegisterType((*URL)(nil), "proto.URL")
proto.RegisterType((*Element)(nil), "proto.Element")
proto.RegisterType((*Certificates)(nil), "proto.Certificates")
proto.RegisterType((*ConnectionState)(nil), "proto.ConnectionState")
proto.RegisterType((*Request)(nil), "proto.Request")
proto.RegisterType((*HTTPRequest)(nil), "proto.HTTPRequest")
proto.RegisterType((*HTTPResponse)(nil), "proto.HTTPResponse")
}
@ -198,22 +646,58 @@ func init() {
func init() { proto.RegisterFile("http.proto", fileDescriptor_11b04836674e6f94) }
var fileDescriptor_11b04836674e6f94 = []byte{
// 225 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x8f, 0x4f, 0x4b, 0x03, 0x31,
0x14, 0xc4, 0xd9, 0xcd, 0x76, 0xa5, 0xaf, 0x15, 0xe4, 0x09, 0x12, 0x3c, 0x85, 0xbd, 0x98, 0x53,
0xc1, 0xf5, 0xe4, 0x37, 0xd8, 0xa3, 0x84, 0xde, 0x65, 0x6b, 0x1e, 0x2c, 0x18, 0x9b, 0x35, 0x7f,
0x84, 0x7e, 0x7b, 0x49, 0xd2, 0xa5, 0x7a, 0xeb, 0x29, 0x33, 0x93, 0x0c, 0xbf, 0x09, 0xc0, 0x14,
0xc2, 0xbc, 0x9b, 0x9d, 0x0d, 0x16, 0x57, 0xf9, 0xe8, 0x7a, 0x68, 0x07, 0x1a, 0x35, 0x39, 0xbc,
0x03, 0xf6, 0x49, 0x27, 0x5e, 0x89, 0x4a, 0xae, 0x55, 0x92, 0xf8, 0x00, 0xed, 0xcf, 0x68, 0x22,
0x79, 0x5e, 0x0b, 0x26, 0xd7, 0xea, 0xec, 0xba, 0x00, 0x9b, 0x61, 0xbf, 0x7f, 0x53, 0xf4, 0x1d,
0xc9, 0x87, 0x54, 0x8c, 0xce, 0x2c, 0xc5, 0xe8, 0x4c, 0x2a, 0x7e, 0x51, 0x98, 0xac, 0xe6, 0x75,
0x0e, 0xcf, 0x0e, 0x9f, 0xe0, 0x66, 0xca, 0x30, 0xcf, 0x99, 0x60, 0x72, 0xd3, 0xdf, 0x96, 0x31,
0xbb, 0x32, 0x41, 0x2d, 0xb7, 0x88, 0xd0, 0x1c, 0xac, 0x3e, 0xf1, 0x46, 0x54, 0x72, 0xab, 0xb2,
0xee, 0xde, 0x61, 0x5b, 0xa8, 0x7e, 0xb6, 0x47, 0x4f, 0xe9, 0xcd, 0x87, 0xd5, 0x94, 0xb9, 0x2b,
0x95, 0xf5, 0x5f, 0x40, 0x7d, 0x15, 0x80, 0x5d, 0x00, 0xfd, 0x2b, 0x34, 0x09, 0x80, 0xcf, 0xd0,
0x0e, 0xe3, 0x51, 0x1b, 0x42, 0x5c, 0xda, 0x97, 0xdf, 0x3e, 0xde, 0xff, 0xcb, 0xca, 0x96, 0x43,
0x9b, 0xb3, 0x97, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbf, 0x5a, 0x2a, 0xb5, 0x61, 0x01, 0x00,
0x00,
// 816 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xdb, 0x6e, 0x1b, 0x37,
0x10, 0x85, 0xb2, 0xb2, 0x2e, 0xa3, 0x8b, 0x5d, 0xa6, 0x08, 0x08, 0x37, 0x28, 0x84, 0x6d, 0x11,
0x08, 0x41, 0x61, 0xa0, 0xce, 0x53, 0x51, 0xa0, 0x17, 0x18, 0x29, 0x12, 0xd4, 0x29, 0x5c, 0xda,
0x46, 0x1f, 0x0b, 0x66, 0x77, 0xa4, 0x65, 0xb3, 0x4b, 0x6e, 0x48, 0xae, 0x0c, 0x7f, 0x47, 0x3f,
0xa3, 0xbf, 0xd7, 0x0f, 0x28, 0x78, 0x59, 0x69, 0x15, 0xb9, 0x7e, 0xda, 0x99, 0x73, 0x86, 0xcb,
0x99, 0x39, 0x33, 0x04, 0x28, 0xac, 0xad, 0xcf, 0x6a, 0xad, 0xac, 0x22, 0x47, 0xfe, 0x93, 0xe6,
0x30, 0xba, 0x35, 0xa8, 0x85, 0x5c, 0x29, 0x72, 0x0a, 0xa3, 0xc6, 0xa0, 0x96, 0xbc, 0x42, 0xda,
0x5b, 0xf4, 0x96, 0x63, 0xb6, 0xf5, 0x1d, 0x57, 0x73, 0x63, 0xee, 0x94, 0xce, 0xe9, 0x93, 0xc0,
0xb5, 0x3e, 0x59, 0xc0, 0xa4, 0xb5, 0xaf, 0xd1, 0xd2, 0x64, 0xd1, 0x5b, 0x8e, 0x58, 0x17, 0x4a,
0xff, 0xed, 0x41, 0x72, 0xcb, 0x2e, 0xc9, 0x33, 0x18, 0x98, 0xac, 0xc0, 0xed, 0xff, 0xa3, 0xe7,
0x70, 0x55, 0xf3, 0x8f, 0x0d, 0xc6, 0x7f, 0x47, 0x8f, 0x7c, 0x05, 0x7d, 0x97, 0x81, 0xff, 0xe5,
0xe4, 0xfc, 0x38, 0xa4, 0x7e, 0xd6, 0x26, 0xcc, 0x3c, 0x49, 0x08, 0xf4, 0x0b, 0x65, 0x2c, 0xed,
0xfb, 0xa3, 0xde, 0x76, 0x58, 0xcd, 0x6d, 0x41, 0x8f, 0x02, 0xe6, 0x6c, 0x42, 0x61, 0xa8, 0xf9,
0xdd, 0x95, 0x83, 0x07, 0x1e, 0x6e, 0x5d, 0xf2, 0x25, 0xc0, 0x4a, 0xe9, 0x0c, 0x7f, 0x6f, 0x50,
0xdf, 0xd3, 0xa1, 0xcf, 0xbf, 0x83, 0xb8, 0xe2, 0x35, 0xbf, 0x0b, 0xec, 0x28, 0x14, 0xdf, 0xfa,
0x8e, 0x5b, 0x69, 0xbe, 0xae, 0x50, 0x5a, 0x3a, 0x0e, 0x5c, 0xeb, 0xa7, 0xaf, 0x60, 0xf8, 0xba,
0x44, 0x67, 0x92, 0x13, 0x48, 0x3e, 0xe0, 0x7d, 0x2c, 0xdb, 0x99, 0xae, 0xe6, 0x0d, 0x2f, 0x1b,
0x34, 0xf4, 0xc9, 0x22, 0x71, 0x35, 0x07, 0x2f, 0x4d, 0x61, 0x7a, 0x81, 0xda, 0x8a, 0x95, 0xc8,
0xb8, 0x45, 0xe3, 0x4a, 0xc9, 0x50, 0x5b, 0xda, 0x5b, 0x24, 0xcb, 0x29, 0xf3, 0x76, 0xfa, 0x4f,
0x1f, 0x8e, 0x2f, 0x94, 0x94, 0x98, 0x59, 0xa1, 0xe4, 0xb5, 0xe5, 0x16, 0x5d, 0x79, 0x1b, 0xd4,
0x46, 0x28, 0xe9, 0x6f, 0x99, 0xb1, 0xd6, 0x25, 0xdf, 0xc0, 0x67, 0x05, 0x97, 0xb9, 0x29, 0xf8,
0x07, 0xbc, 0x50, 0x55, 0x5d, 0xa2, 0x0d, 0x8d, 0x1e, 0xb1, 0x43, 0x82, 0x3c, 0x87, 0x71, 0x2e,
0x72, 0x86, 0xa6, 0xa9, 0x30, 0x6a, 0xb9, 0x03, 0x9c, 0xd6, 0x99, 0xa8, 0x0b, 0xd4, 0xd7, 0x8d,
0xb0, 0xe8, 0x7b, 0x3e, 0x63, 0x5d, 0x88, 0x9c, 0x01, 0x91, 0xb8, 0x56, 0x56, 0x70, 0x8b, 0xf9,
0x95, 0x13, 0x2c, 0x53, 0x65, 0x14, 0xe2, 0x01, 0x86, 0xfc, 0x00, 0xa7, 0x87, 0xe8, 0x5b, 0xf3,
0xae, 0xb1, 0x0d, 0x2f, 0xbd, 0x52, 0x23, 0xf6, 0x48, 0x84, 0x13, 0xcf, 0xa0, 0xde, 0xa0, 0xfe,
0xcd, 0xcd, 0xed, 0xd0, 0xdf, 0xd3, 0x41, 0xc8, 0x8f, 0x70, 0x52, 0x23, 0xea, 0x6e, 0x4f, 0xbd,
0x88, 0x93, 0xf3, 0xa7, 0x71, 0x9e, 0xba, 0x14, 0x3b, 0x08, 0x26, 0xdf, 0xc3, 0x7c, 0x83, 0x5a,
0xac, 0x04, 0xe6, 0x17, 0x05, 0x17, 0xd2, 0xd0, 0xf1, 0x22, 0xf9, 0xbf, 0xe3, 0x9f, 0x84, 0x92,
0x9f, 0xe0, 0x0b, 0x23, 0xd6, 0x12, 0xf3, 0x4e, 0xd4, 0x8d, 0xa8, 0xd0, 0x58, 0x5e, 0xd5, 0x86,
0x82, 0x17, 0xf5, 0xb1, 0x10, 0x92, 0xc2, 0x54, 0x65, 0xa6, 0x66, 0x68, 0x6a, 0x25, 0x0d, 0xd2,
0xc9, 0xa2, 0xb7, 0x9c, 0xb2, 0x3d, 0xcc, 0x69, 0x66, 0x4b, 0x73, 0x2b, 0x85, 0x5b, 0xa1, 0xa9,
0x0f, 0xd8, 0x01, 0xe9, 0xdf, 0x7d, 0x18, 0x32, 0xfc, 0xd8, 0xa0, 0xb1, 0x6e, 0xea, 0x2a, 0xb4,
0x85, 0xca, 0xdb, 0x0d, 0x0c, 0x1e, 0x79, 0x0e, 0x49, 0xa3, 0x4b, 0x3f, 0x15, 0x93, 0x73, 0x68,
0x17, 0x8d, 0x5d, 0x32, 0x07, 0x93, 0xcf, 0x21, 0x3c, 0x17, 0x7e, 0x1e, 0xc6, 0x2c, 0x38, 0xae,
0xf3, 0xde, 0x78, 0xc7, 0xff, 0x52, 0xda, 0x8f, 0xc2, 0x11, 0xeb, 0x20, 0x3b, 0x5e, 0x48, 0xa5,
0xfd, 0x04, 0x6c, 0x79, 0x87, 0x90, 0x17, 0x30, 0x28, 0x90, 0xe7, 0xa8, 0xe9, 0xc0, 0x37, 0x74,
0x1e, 0xaf, 0x8d, 0x3b, 0xc3, 0x22, 0xeb, 0x36, 0xe0, 0xbd, 0xca, 0xc3, 0x62, 0xce, 0x98, 0xb7,
0xc9, 0xd7, 0x30, 0xcb, 0x94, 0xb4, 0x28, 0xed, 0x25, 0xca, 0xb5, 0x2d, 0xbc, 0xa4, 0x09, 0xdb,
0x07, 0xc9, 0x4b, 0x38, 0xb1, 0x9a, 0x4b, 0xb3, 0x42, 0xfd, 0x5a, 0x66, 0x2a, 0x17, 0x72, 0xed,
0xc5, 0x1b, 0xb3, 0x03, 0x7c, 0xfb, 0x8c, 0x40, 0xe7, 0x19, 0x49, 0xa1, 0xbf, 0x52, 0xba, 0xa2,
0x93, 0x07, 0xf3, 0xf3, 0x1c, 0x79, 0x09, 0xa3, 0x5a, 0x19, 0xfb, 0x8b, 0x8b, 0x9b, 0x3e, 0x18,
0xb7, 0xe5, 0xdd, 0xf6, 0x58, 0xcd, 0x45, 0x89, 0xfa, 0x57, 0xbc, 0x37, 0x74, 0xe6, 0x53, 0xe9,
0x42, 0xae, 0x67, 0x1a, 0x2b, 0x65, 0xf1, 0xe7, 0x3c, 0xd7, 0x74, 0x1e, 0xa6, 0x79, 0x87, 0x04,
0xde, 0x4b, 0x79, 0xcb, 0xde, 0xd2, 0xe3, 0x96, 0x6f, 0x11, 0xb2, 0x84, 0xc4, 0x96, 0x86, 0x9e,
0x78, 0x1d, 0x9f, 0xb5, 0x13, 0xba, 0xff, 0x54, 0x30, 0x17, 0x92, 0xfe, 0x09, 0x93, 0x37, 0x37,
0x37, 0x57, 0xed, 0x60, 0xbc, 0x80, 0xb9, 0x8e, 0xe3, 0xf4, 0x87, 0x16, 0x16, 0x75, 0x7c, 0x45,
0x3e, 0x41, 0xc9, 0x12, 0x86, 0xf1, 0xba, 0x38, 0x2c, 0x6d, 0xb5, 0xf1, 0x47, 0xac, 0xa5, 0xd3,
0x39, 0x4c, 0xc3, 0x05, 0xe1, 0xfc, 0xf9, 0x77, 0xd0, 0x77, 0x3e, 0xf9, 0x16, 0x06, 0x6f, 0xb8,
0xcc, 0x4b, 0x24, 0x24, 0x1e, 0xed, 0xe4, 0x71, 0xfa, 0x74, 0x0f, 0x0b, 0x47, 0xdf, 0x0f, 0x3c,
0xf6, 0xea, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbf, 0x29, 0xb2, 0xd4, 0xc1, 0x06, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

71
vms/rpcchainvm/ghttp/proto/http.proto
View File

@ -1,24 +1,75 @@
syntax = "proto3";
package proto;
message Header {
message Userinfo {
string username = 1;
string password = 2;
bool passwordSet = 3;
}
message URL {
string scheme = 1;
string opaque = 2;
Userinfo user = 3;
string host = 4;
string path = 5;
string rawPath = 6;
bool forceQuery = 7;
string rawQuery = 8;
string fragment = 9;
}
message Element {
string key = 1;
repeated string values = 2;
}
message HTTPRequest {
string url = 1;
string method = 2;
repeated Header headers = 3;
bytes body = 4;
message Certificates {
repeated bytes cert = 1;
}
message HTTPResponse {
int32 code = 1;
repeated Header headers = 2;
bytes body = 3;
message ConnectionState {
uint32 version = 1;
bool handshakeComplete = 2;
bool didResume = 3;
uint32 cipherSuite = 4;
string negotiatedProtocol = 5;
bool negotiatedProtocolIsMutual = 6;
string serverName = 7;
Certificates peerCertificates = 8;
repeated Certificates verifiedChains = 9;
repeated bytes signedCertificateTimestamps = 10;
bytes ocspResponse = 11;
bytes tlsUnique = 12;
}
message Request {
string method = 1;
URL url = 2;
string proto = 3;
int32 protoMajor = 4;
int32 protoMinor = 5;
repeated Element header = 6;
uint32 body = 7; // server ID
int64 contentLength = 8;
repeated string transferEncoding = 9;
string host = 10;
repeated Element form = 11;
repeated Element postForm = 12;
repeated string trailerKeys = 13;
string remoteAddr = 14;
string requestURI = 15;
ConnectionState tls = 16;
}
message HTTPRequest {
uint32 responseWriter = 1; // server ID
Request request = 2;
}
message HTTPResponse {}
service HTTP {
rpc Handle(HTTPRequest) returns (HTTPResponse);
}

2
vms/rpcchainvm/vm_client.go
View File

@ -172,7 +172,7 @@ func (vm *VMClient) CreateHandlers() map[string]*common.HTTPHandler {
vm.conns = append(vm.conns, conn)
handlers[handler.Prefix] = &common.HTTPHandler{
LockOptions: common.LockOption(handler.LockOptions),
Handler: ghttp.NewClient(httpproto.NewHTTPClient(conn)),
Handler: ghttp.NewClient(httpproto.NewHTTPClient(conn), vm.broker),
}
}
return handlers

2
vms/rpcchainvm/vm_server.go
View File

@ -127,7 +127,7 @@ func (vm *VMServer) CreateHandlers(_ context.Context, req *vmproto.CreateHandler
vm.servers = append(vm.servers, server)
}
httpproto.RegisterHTTPServer(server, ghttp.NewServer(handler.Handler))
httpproto.RegisterHTTPServer(server, ghttp.NewServer(handler.Handler, vm.broker))
return server
})