2016-12-14 17:41:48 +02:00
|
|
|
// Package server is an interface for a micro server
|
2015-01-14 01:31:27 +02:00
|
|
|
package server
|
|
|
|
|
|
|
|
import (
|
2018-03-03 13:53:52 +02:00
|
|
|
"context"
|
2018-04-17 12:00:22 +02:00
|
|
|
"os"
|
|
|
|
"os/signal"
|
|
|
|
"syscall"
|
2019-08-21 16:43:46 +02:00
|
|
|
"time"
|
2015-01-14 01:31:27 +02:00
|
|
|
|
2018-11-21 12:13:03 +02:00
|
|
|
"github.com/google/uuid"
|
2019-01-07 20:20:47 +02:00
|
|
|
"github.com/micro/go-micro/codec"
|
2018-11-26 16:51:42 +02:00
|
|
|
"github.com/micro/go-micro/registry"
|
2019-05-31 01:38:05 +02:00
|
|
|
log "github.com/micro/go-micro/util/log"
|
2015-01-14 01:31:27 +02:00
|
|
|
)
|
|
|
|
|
2018-11-26 16:51:42 +02:00
|
|
|
// Server is a simple micro server abstraction
|
2015-01-14 01:31:27 +02:00
|
|
|
type Server interface {
|
2015-12-31 20:11:46 +02:00
|
|
|
Options() Options
|
2016-01-02 21:12:17 +02:00
|
|
|
Init(...Option) error
|
2015-06-03 02:25:37 +02:00
|
|
|
Handle(Handler) error
|
2016-01-08 16:02:32 +02:00
|
|
|
NewHandler(interface{}, ...HandlerOption) Handler
|
|
|
|
NewSubscriber(string, interface{}, ...SubscriberOption) Subscriber
|
2015-06-12 20:52:27 +02:00
|
|
|
Subscribe(Subscriber) error
|
2015-01-14 01:31:27 +02:00
|
|
|
Start() error
|
|
|
|
Stop() error
|
2015-12-19 23:56:14 +02:00
|
|
|
String() string
|
2015-01-14 01:31:27 +02:00
|
|
|
}
|
|
|
|
|
2019-01-07 16:44:40 +02:00
|
|
|
// Router handle serving messages
|
|
|
|
type Router interface {
|
2019-01-09 18:20:57 +02:00
|
|
|
// ServeRequest processes a request to completion
|
2019-01-09 21:11:47 +02:00
|
|
|
ServeRequest(context.Context, Request, Response) error
|
2019-01-07 16:44:40 +02:00
|
|
|
}
|
|
|
|
|
2018-11-26 16:51:42 +02:00
|
|
|
// Message is an async message interface
|
2018-04-14 19:21:02 +02:00
|
|
|
type Message interface {
|
2015-12-02 22:56:50 +02:00
|
|
|
Topic() string
|
2018-04-14 19:21:02 +02:00
|
|
|
Payload() interface{}
|
2015-12-02 22:56:50 +02:00
|
|
|
ContentType() string
|
|
|
|
}
|
|
|
|
|
2018-11-26 16:51:42 +02:00
|
|
|
// Request is a synchronous request interface
|
2015-12-02 22:56:50 +02:00
|
|
|
type Request interface {
|
2019-01-09 18:20:57 +02:00
|
|
|
// Service name requested
|
2015-12-02 22:56:50 +02:00
|
|
|
Service() string
|
2019-01-18 12:12:57 +02:00
|
|
|
// The action requested
|
|
|
|
Method() string
|
2019-01-10 23:25:31 +02:00
|
|
|
// Endpoint name requested
|
|
|
|
Endpoint() string
|
2019-01-09 18:20:57 +02:00
|
|
|
// Content type provided
|
2015-12-02 22:56:50 +02:00
|
|
|
ContentType() string
|
2019-01-09 21:11:47 +02:00
|
|
|
// Header of the request
|
|
|
|
Header() map[string]string
|
2019-02-04 15:13:03 +02:00
|
|
|
// Body is the initial decoded value
|
|
|
|
Body() interface{}
|
2019-01-09 21:11:47 +02:00
|
|
|
// Read the undecoded request body
|
|
|
|
Read() ([]byte, error)
|
|
|
|
// The encoded message stream
|
2019-01-09 21:28:13 +02:00
|
|
|
Codec() codec.Reader
|
2019-01-09 18:20:57 +02:00
|
|
|
// Indicates whether its a stream
|
2015-12-02 22:56:50 +02:00
|
|
|
Stream() bool
|
|
|
|
}
|
|
|
|
|
2019-01-09 21:11:47 +02:00
|
|
|
// Response is the response writer for unencoded messages
|
|
|
|
type Response interface {
|
2019-01-09 21:28:13 +02:00
|
|
|
// Encoded writer
|
|
|
|
Codec() codec.Writer
|
2019-01-09 21:11:47 +02:00
|
|
|
// Write the header
|
|
|
|
WriteHeader(map[string]string)
|
|
|
|
// write a response directly to the client
|
|
|
|
Write([]byte) error
|
|
|
|
}
|
|
|
|
|
2018-04-14 19:15:09 +02:00
|
|
|
// Stream represents a stream established with a client.
|
2015-12-17 22:37:35 +02:00
|
|
|
// A stream can be bidirectional which is indicated by the request.
|
|
|
|
// The last error will be left in Error().
|
2018-11-26 16:51:42 +02:00
|
|
|
// EOF indicates end of the stream.
|
2018-04-14 19:15:09 +02:00
|
|
|
type Stream interface {
|
2015-12-17 22:37:35 +02:00
|
|
|
Context() context.Context
|
|
|
|
Request() Request
|
|
|
|
Send(interface{}) error
|
|
|
|
Recv(interface{}) error
|
|
|
|
Error() error
|
|
|
|
Close() error
|
|
|
|
}
|
|
|
|
|
2018-11-26 16:51:42 +02:00
|
|
|
// Handler interface represents a request handler. It's generated
|
2019-01-10 23:25:31 +02:00
|
|
|
// by passing any type of public concrete object with endpoints into server.NewHandler.
|
2018-11-26 16:51:42 +02: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
|
2019-01-10 23:25:31 +02:00
|
|
|
// a specific subscriber function or object with endpoints.
|
2018-11-26 16:51:42 +02:00
|
|
|
type Subscriber interface {
|
|
|
|
Topic() string
|
|
|
|
Subscriber() interface{}
|
|
|
|
Endpoints() []*registry.Endpoint
|
|
|
|
Options() SubscriberOptions
|
|
|
|
}
|
|
|
|
|
2015-12-31 20:11:46 +02:00
|
|
|
type Option func(*Options)
|
2015-05-21 20:24:57 +02:00
|
|
|
|
2015-01-14 01:31:27 +02:00
|
|
|
var (
|
2019-09-23 18:59:34 +02:00
|
|
|
DefaultAddress = ":0"
|
|
|
|
DefaultName = "go.micro.server"
|
|
|
|
DefaultVersion = time.Now().Format("2006.01.02.15.04")
|
|
|
|
DefaultId = uuid.New().String()
|
|
|
|
DefaultServer Server = newRpcServer()
|
|
|
|
DefaultRouter = newRpcRouter()
|
|
|
|
DefaultRegisterCheck = func(context.Context) error { return nil }
|
|
|
|
DefaultRegisterInterval = time.Second * 30
|
|
|
|
DefaultRegisterTTL = time.Minute
|
2015-01-14 01:31:27 +02:00
|
|
|
)
|
|
|
|
|
2018-04-17 12:00:22 +02:00
|
|
|
// DefaultOptions returns config options for the default service
|
|
|
|
func DefaultOptions() Options {
|
|
|
|
return DefaultServer.Options()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Init initialises the default server with options passed in
|
|
|
|
func Init(opt ...Option) {
|
|
|
|
if DefaultServer == nil {
|
|
|
|
DefaultServer = newRpcServer(opt...)
|
|
|
|
}
|
|
|
|
DefaultServer.Init(opt...)
|
|
|
|
}
|
|
|
|
|
2016-04-06 19:03:27 +02:00
|
|
|
// NewServer returns a new server with options passed in
|
2015-05-26 23:39:48 +02:00
|
|
|
func NewServer(opt ...Option) Server {
|
|
|
|
return newRpcServer(opt...)
|
2015-05-23 18:40:53 +02:00
|
|
|
}
|
2018-04-17 12:00:22 +02:00
|
|
|
|
2019-07-31 17:36:53 +02:00
|
|
|
// NewRouter returns a new router
|
|
|
|
func NewRouter() *router {
|
|
|
|
return newRpcRouter()
|
|
|
|
}
|
|
|
|
|
2018-04-17 12:00:22 +02:00
|
|
|
// NewSubscriber creates a new subscriber interface with the given topic
|
|
|
|
// and handler using the default server
|
|
|
|
func NewSubscriber(topic string, h interface{}, opts ...SubscriberOption) Subscriber {
|
|
|
|
return DefaultServer.NewSubscriber(topic, h, opts...)
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewHandler creates a new handler interface using the default server
|
|
|
|
// Handlers are required to be a public object with public
|
2019-01-10 23:25:31 +02:00
|
|
|
// endpoints. Call to a service endpoint such as Foo.Bar expects
|
2018-04-17 12:00:22 +02:00
|
|
|
// the type:
|
|
|
|
//
|
|
|
|
// type Foo struct {}
|
|
|
|
// func (f *Foo) Bar(ctx, req, rsp) error {
|
|
|
|
// return nil
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
func NewHandler(h interface{}, opts ...HandlerOption) Handler {
|
|
|
|
return DefaultServer.NewHandler(h, opts...)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle registers a handler interface with the default server to
|
|
|
|
// handle inbound requests
|
|
|
|
func Handle(h Handler) error {
|
|
|
|
return DefaultServer.Handle(h)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Subscribe registers a subscriber interface with the default server
|
|
|
|
// which subscribes to specified topic with the broker
|
|
|
|
func Subscribe(s Subscriber) error {
|
|
|
|
return DefaultServer.Subscribe(s)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Run starts the default server and waits for a kill
|
|
|
|
// signal before exiting. Also registers/deregisters the server
|
|
|
|
func Run() error {
|
|
|
|
if err := Start(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
ch := make(chan os.Signal, 1)
|
|
|
|
signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
|
|
|
|
log.Logf("Received signal %s", <-ch)
|
|
|
|
|
|
|
|
return Stop()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Start starts the default server
|
|
|
|
func Start() error {
|
|
|
|
config := DefaultServer.Options()
|
|
|
|
log.Logf("Starting server %s id %s", config.Name, config.Id)
|
|
|
|
return DefaultServer.Start()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Stop stops the default server
|
|
|
|
func Stop() error {
|
|
|
|
log.Logf("Stopping server")
|
|
|
|
return DefaultServer.Stop()
|
|
|
|
}
|
|
|
|
|
|
|
|
// String returns name of Server implementation
|
|
|
|
func String() string {
|
|
|
|
return DefaultServer.String()
|
|
|
|
}
|