micro/server/server.go

148 lines
3.6 KiB
Go
Raw Normal View History

2016-12-14 15:41:48 +00:00
// Package server is an interface for a micro server
2015-01-13 23:31:27 +00:00
package server
import (
2018-03-03 11:53:52 +00:00
"context"
"time"
2015-01-13 23:31:27 +00:00
"github.com/google/uuid"
"github.com/unistack-org/micro/v3/codec"
"github.com/unistack-org/micro/v3/registry"
2015-01-13 23:31:27 +00:00
)
var (
DefaultServer Server = newServer()
)
2018-11-26 14:51:42 +00:00
// Server is a simple micro server abstraction
2015-01-13 23:31:27 +00:00
type Server interface {
2020-05-12 11:32:01 +01:00
// Initialise options
2016-01-02 19:12:17 +00:00
Init(...Option) error
2020-05-12 11:32:01 +01:00
// Retrieve the options
Options() Options
// Register a handler
Handle(Handler) error
2020-05-12 11:32:01 +01:00
// Create a new handler
NewHandler(interface{}, ...HandlerOption) Handler
2020-05-12 11:32:01 +01:00
// Create a new subscriber
NewSubscriber(string, interface{}, ...SubscriberOption) Subscriber
2020-05-12 11:32:01 +01:00
// Register a subscriber
Subscribe(Subscriber) error
2020-05-12 11:32:01 +01:00
// Start the server
2015-01-13 23:31:27 +00:00
Start() error
2020-05-12 11:32:01 +01:00
// Stop the server
2015-01-13 23:31:27 +00:00
Stop() error
2020-05-12 11:32:01 +01:00
// Server implementation
2015-12-19 21:56:14 +00:00
String() string
2015-01-13 23:31:27 +00:00
}
2019-01-07 14:44:40 +00:00
// Router handle serving messages
type Router interface {
// ProcessMessage processes a message
ProcessMessage(context.Context, Message) error
2019-01-09 16:20:57 +00:00
// ServeRequest processes a request to completion
2019-01-09 19:11:47 +00:00
ServeRequest(context.Context, Request, Response) error
2019-01-07 14:44:40 +00:00
}
2018-11-26 14:51:42 +00:00
// Message is an async message interface
2018-04-14 18:21:02 +01:00
type Message interface {
// Topic of the message
2015-12-02 20:56:50 +00:00
Topic() string
// The decoded payload value
2018-04-14 18:21:02 +01:00
Payload() interface{}
// The content type of the payload
2015-12-02 20:56:50 +00:00
ContentType() string
// The raw headers of the message
Header() map[string]string
// The raw body of the message
Body() []byte
// Codec used to decode the message
Codec() codec.Reader
2015-12-02 20:56:50 +00:00
}
2018-11-26 14:51:42 +00:00
// Request is a synchronous request interface
2015-12-02 20:56:50 +00:00
type Request interface {
2019-01-09 16:20:57 +00:00
// Service name requested
2015-12-02 20:56:50 +00:00
Service() string
2019-01-18 10:12:57 +00:00
// The action requested
Method() string
2019-01-10 21:25:31 +00:00
// Endpoint name requested
Endpoint() string
2019-01-09 16:20:57 +00:00
// Content type provided
2015-12-02 20:56:50 +00:00
ContentType() string
2019-01-09 19:11:47 +00:00
// Header of the request
Header() map[string]string
2019-02-04 13:13:03 +00:00
// Body is the initial decoded value
Body() interface{}
2019-01-09 19:11:47 +00:00
// Read the undecoded request body
Read() ([]byte, error)
// The encoded message stream
2019-01-09 19:28:13 +00:00
Codec() codec.Reader
2019-01-09 16:20:57 +00:00
// Indicates whether its a stream
2015-12-02 20:56:50 +00:00
Stream() bool
}
2019-01-09 19:11:47 +00:00
// Response is the response writer for unencoded messages
type Response interface {
2019-01-09 19:28:13 +00:00
// Encoded writer
Codec() codec.Writer
2019-01-09 19:11:47 +00:00
// Write the header
WriteHeader(map[string]string)
// write a response directly to the client
Write([]byte) error
}
2018-04-14 18:15:09 +01:00
// Stream represents a stream established with a client.
2015-12-17 20:37:35 +00:00
// A stream can be bidirectional which is indicated by the request.
// The last error will be left in Error().
2018-11-26 14:51:42 +00:00
// EOF indicates end of the stream.
2018-04-14 18:15:09 +01:00
type Stream interface {
2015-12-17 20:37:35 +00:00
Context() context.Context
Request() Request
Send(interface{}) error
Recv(interface{}) error
Error() error
Close() error
}
2018-11-26 14:51:42 +00:00
// Handler interface represents a request handler. It's generated
2019-01-10 21:25:31 +00:00
// by passing any type of public concrete object with endpoints into server.NewHandler.
2018-11-26 14:51:42 +00:00
// Most will pass in a struct.
//
// Example:
//
// type Greeter struct {}
//
// func (g *Greeter) Hello(context, request, response) error {
// return nil
// }
//
type Handler interface {
Name() string
Handler() interface{}
Endpoints() []*registry.Endpoint
Options() HandlerOptions
}
// Subscriber interface represents a subscription to a given topic using
// a specific subscriber function or object with endpoints. It mirrors
2020-05-12 11:32:01 +01:00
// the handler in its behaviour.
2018-11-26 14:51:42 +00:00
type Subscriber interface {
Topic() string
Subscriber() interface{}
Endpoints() []*registry.Endpoint
Options() SubscriberOptions
}
type Option func(*Options)
2015-05-21 19:24:57 +01:00
2015-01-13 23:31:27 +00:00
var (
DefaultAddress = ":0"
DefaultName = "server"
DefaultVersion = "latest"
DefaultId = uuid.New().String()
DefaultRegisterCheck = func(context.Context) error { return nil }
DefaultRegisterInterval = time.Second * 30
DefaultRegisterTTL = time.Second * 90
2015-01-13 23:31:27 +00:00
)