server

package
v0.0.0-...-580d7e6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 14, 2018 License: MIT Imports: 15 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ByteHandler 

func ByteHandler(in []byte, serviceEndpointMap ServiceEndpointMap) (out []byte, err error)

ByteHandler is an implementation of the ServerHandler. It takes in a slice of bytes, coming in from the network and demultiplexes the message using a map provided to it with all the service endpoints.

func RegisterMessageServiceServer 

func RegisterMessageServiceServer(s *grpc.Server, srv MessageServiceServer)

Types

type Handler 

type Handler func(in []byte, serviceEndpointMap ServiceEndpointMap) (out []byte, err error)

Handler is a func signature implemented by the Endpoint Handle() method

type KafkaConsumer 

type KafkaConsumer struct {
	// contains filtered or unexported fields
}

KafkaConsumer encapsulates all members used for the kafka server.

func MyKafkaConsumer 

func MyKafkaConsumer(cfg *configuration.KafkaConfig) (kc *KafkaConsumer, err error)

MyKafkaConsumer takes in configuration object and returns a new KafkaConsumer instance.

func (*KafkaConsumer) RegisterNamespace 

func (kc *KafkaConsumer) RegisterNamespace(name string)

RegisterNamespace is an implementation of the Server RegisterNamespace method. In kafka a namespace is the same as the channel name.

func (*KafkaConsumer) RegisterService 

func (kc *KafkaConsumer) RegisterService(namespace string, service Service, ep endpoint.Endpoint)

RegisterService is an implementation of the server RegisterService method. In kafka this is used to demux the messages coming in on a single channel/topic.

func (*KafkaConsumer) Start 

func (kc *KafkaConsumer) Start() (err error)

Start is an implementation of the Server Start() method.

func (*KafkaConsumer) Stop 

func (kc *KafkaConsumer) Stop() (err error)

Stop is an implementation of the Server Stop() method

type KafkaProducer 

type KafkaProducer struct {
	// contains filtered or unexported fields
}

KafkaProducer encapsulates all the members used by a kafka producer

func MyKafkaProducer 

func MyKafkaProducer(cfg *configuration.KafkaConfig) (kp *KafkaProducer, err error)

MyKafkaProducer takes in a configuration object and returns a KafkaProducer instance.

func (*KafkaProducer) Produce 

func (kp *KafkaProducer) Produce(topic string, msg interface{}) (err error)

Produce is used by the client to send a message through kafka producer.

func (*KafkaProducer) Start 

func (kp *KafkaProducer) Start() (err error)

Start is used to start a go routine for the kafka producer. All messages produced are read by the msgChan passed to the producer() method.

func (*KafkaProducer) Stop 

func (kp *KafkaProducer) Stop() (err error)

Stop gracefully stops the kafka producer by writing to the quit channel.

type Message 

type Message struct {
	// Service is the service identifier. Set this to a unique string for a given server
	Service Service `json:"service,omitempty"`
	// ServiceMessage is the actual payload passed over the network.
	ServiceMessage string `json:"service_message,omitempty"`
}

Message defines the message structure to be used by the microservice framework. It provides a mechanism to demux messages coming in a namespace by using its Service identifier.

type MessageServiceClient 

type MessageServiceClient interface {
	Command(ctx context.Context, in *RPCMessage, opts ...grpc.CallOption) (*RPCResponse, error)
}

func NewMessageServiceClient 

func NewMessageServiceClient(cc *grpc.ClientConn) MessageServiceClient

type MessageServiceServer 

type MessageServiceServer interface {
	Command(context.Context, *RPCMessage) (*RPCResponse, error)
}

type RPCClient 

type RPCClient struct {
	// contains filtered or unexported fields
}

func MyRPCClient 

func MyRPCClient(cfg *configuration.RPCConfig) (rpc *RPCClient, err error)

func (*RPCClient) Send 

func (rpc *RPCClient) Send(namespace string, msg interface{}) (resp string, err error)

type RPCMessage 

type RPCMessage struct {
	Namespace            string   `protobuf:"bytes,1,opt,name=Namespace" json:"Namespace,omitempty"`
	Data                 []byte   `protobuf:"bytes,2,opt,name=Data,proto3" json:"Data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*RPCMessage) Descriptor 

func (*RPCMessage) Descriptor() ([]byte, []int)

func (*RPCMessage) GetData 

func (m *RPCMessage) GetData() []byte

func (*RPCMessage) GetNamespace 

func (m *RPCMessage) GetNamespace() string

func (*RPCMessage) ProtoMessage 

func (*RPCMessage) ProtoMessage()

func (*RPCMessage) Reset 

func (m *RPCMessage) Reset()

func (*RPCMessage) String 

func (m *RPCMessage) String() string

func (*RPCMessage) XXX_DiscardUnknown 

func (m *RPCMessage) XXX_DiscardUnknown()

func (*RPCMessage) XXX_Marshal 

func (m *RPCMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*RPCMessage) XXX_Merge 

func (dst *RPCMessage) XXX_Merge(src proto.Message)

func (*RPCMessage) XXX_Size 

func (m *RPCMessage) XXX_Size() int

func (*RPCMessage) XXX_Unmarshal 

func (m *RPCMessage) XXX_Unmarshal(b []byte) error

type RPCNamespace 

type RPCNamespace struct {
	Name               string
	ServiceEndpointMap ServiceEndpointMap
}

func MyRPCNamespace 

func MyRPCNamespace(name string) (namespace RPCNamespace)

type RPCResponse 

type RPCResponse struct {
	Data                 []byte   `protobuf:"bytes,1,opt,name=Data,proto3" json:"Data,omitempty"`
	Error                string   `protobuf:"bytes,2,opt,name=Error" json:"Error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*RPCResponse) Descriptor 

func (*RPCResponse) Descriptor() ([]byte, []int)

func (*RPCResponse) GetData 

func (m *RPCResponse) GetData() []byte

func (*RPCResponse) GetError 

func (m *RPCResponse) GetError() string

func (*RPCResponse) ProtoMessage 

func (*RPCResponse) ProtoMessage()

func (*RPCResponse) Reset 

func (m *RPCResponse) Reset()

func (*RPCResponse) String 

func (m *RPCResponse) String() string

func (*RPCResponse) XXX_DiscardUnknown 

func (m *RPCResponse) XXX_DiscardUnknown()

func (*RPCResponse) XXX_Marshal 

func (m *RPCResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*RPCResponse) XXX_Merge 

func (dst *RPCResponse) XXX_Merge(src proto.Message)

func (*RPCResponse) XXX_Size 

func (m *RPCResponse) XXX_Size() int

func (*RPCResponse) XXX_Unmarshal 

func (m *RPCResponse) XXX_Unmarshal(b []byte) error

type RPCServer 

type RPCServer struct {
	// contains filtered or unexported fields
}

func MyRPCServer 

func MyRPCServer(cfg *configuration.RPCConfig) (rpc *RPCServer, err error)

func (*RPCServer) Command 

func (rpc *RPCServer) Command(c context.Context, msg *RPCMessage) (resp *RPCResponse, err error)

func (*RPCServer) RegisterNamespace 

func (rpc *RPCServer) RegisterNamespace(name string)

func (*RPCServer) RegisterService 

func (rpc *RPCServer) RegisterService(namespace string, service Service, ep endpoint.Endpoint)

func (*RPCServer) Start 

func (rpc *RPCServer) Start() (err error)

func (*RPCServer) Stop 

func (rpc *RPCServer) Stop() (err error)

type ServerInterface 

type ServerInterface interface {
	StartStopInterface
	// RegisterNamesapce is used to register a namespace (like a kafka channel/topic or grpc namespace)
	// with the server.
	RegisterNamespace(namespace string)
	// RegisterService is used to register a service and its endpoints with the server.
	RegisterService(namespace string, service Service, endpoint endpoint.Endpoint)
}

ServerInterface defines the methods that all servers registed with the microservice must implement

type ServerType 

type ServerType string

ServerType is a typedef for server identifier

type Service 

type Service string

Service is a typedef for service identifier

type ServiceEndpointMap 

type ServiceEndpointMap map[Service]endpoint.Endpoint

ServiceEndpointMap is a typedef for a map of Service endpoints identified by their service type

type StartStopInterface 

type StartStopInterface interface {
	// Start is used to start the server
	Start() (err error)
	// Stop is used to gracefully stop the server
	Stop() (err error)
}

StartStopInterface is composed of the Start() and Stop() methods to be implemented by the server

type Topic 

type Topic struct {
	Name               string
	ServiceEndpointMap ServiceEndpointMap
}

Topic encapsulates a kafka channel name and a map of endpoints used on that channel

func MyTopic 

func MyTopic(name string) (topic Topic)

MyTopic returns a new Topic instance

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.