1
0
mirror of https://github.com/go-micro/go-micro.git synced 2024-12-12 08:23:58 +02:00
go-micro/server/server.go

216 lines
5.5 KiB
Go
Raw Normal View History

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"
"time"
2015-01-14 01:31:27 +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 {
Options() Options
2016-01-02 21:12:17 +02:00
Init(...Option) error
Handle(Handler) error
NewHandler(interface{}, ...HandlerOption) Handler
NewSubscriber(string, interface{}, ...SubscriberOption) Subscriber
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
}
type Option func(*Options)
2015-05-21 20:24:57 +02:00
2015-01-14 01:31:27 +02:00
var (
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
// 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()
}