41 |
42 |
43 |
44 |
--------------------------------------------------------------------------------
/logger/context.go:
--------------------------------------------------------------------------------
1 | package logger
2 |
3 | import "context"
4 |
5 | type loggerKey struct{}
6 |
7 | func FromContext(ctx context.Context) (Logger, bool) {
8 | l, ok := ctx.Value(loggerKey{}).(Logger)
9 | return l, ok
10 | }
11 |
12 | func NewContext(ctx context.Context, l Logger) context.Context {
13 | return context.WithValue(ctx, loggerKey{}, l)
14 | }
15 |
--------------------------------------------------------------------------------
/logger/logger.go:
--------------------------------------------------------------------------------
1 | // Package log provides a log interface
2 | package logger
3 |
4 | var (
5 | // Default logger.
6 | DefaultLogger Logger = NewLogger()
7 |
8 | // Default logger helper.
9 | DefaultHelper *Helper = NewHelper(DefaultLogger)
10 | )
11 |
12 | // Logger is a generic logging interface.
13 | type Logger interface {
14 | // Init initializes options
15 | Init(options ...Option) error
16 | // The Logger options
17 | Options() Options
18 | // Fields set fields to always be logged
19 | Fields(fields map[string]interface{}) Logger
20 | // Log writes a log entry
21 | Log(level Level, v ...interface{})
22 | // Logf writes a formatted log entry
23 | Logf(level Level, format string, v ...interface{})
24 | // String returns the name of logger
25 | String() string
26 | }
27 |
28 | func Init(opts ...Option) error {
29 | return DefaultLogger.Init(opts...)
30 | }
31 |
32 | func Fields(fields map[string]interface{}) Logger {
33 | return DefaultLogger.Fields(fields)
34 | }
35 |
36 | func Log(level Level, v ...interface{}) {
37 | DefaultLogger.Log(level, v...)
38 | }
39 |
40 | func Logf(level Level, format string, v ...interface{}) {
41 | DefaultLogger.Logf(level, format, v...)
42 | }
43 |
44 | func String() string {
45 | return DefaultLogger.String()
46 | }
47 |
48 | func LoggerOrDefault(l Logger) Logger {
49 | if l == nil {
50 | return DefaultLogger
51 | }
52 | return l
53 | }
54 |
--------------------------------------------------------------------------------
/logger/logger_test.go:
--------------------------------------------------------------------------------
1 | package logger
2 |
3 | import (
4 | "context"
5 | "testing"
6 | )
7 |
8 | func TestLogger(t *testing.T) {
9 | l := NewLogger(WithLevel(TraceLevel), WithCallerSkipCount(2))
10 |
11 | h1 := NewHelper(l).WithFields(map[string]interface{}{"key1": "val1"})
12 | h1.Log(TraceLevel, "simple log before trace_msg1")
13 | h1.Trace("trace_msg1")
14 | h1.Log(TraceLevel, "simple log after trace_msg1")
15 | h1.Warn("warn_msg1")
16 |
17 | h2 := NewHelper(l).WithFields(map[string]interface{}{"key2": "val2"})
18 | h2.Logf(TraceLevel, "formatted log before trace_msg%s", "2")
19 | h2.Trace("trace_msg2")
20 | h2.Logf(TraceLevel, "formatted log after trace_msg%s", "2")
21 | h2.Warn("warn_msg2")
22 |
23 | l = NewLogger(WithLevel(TraceLevel), WithCallerSkipCount(1))
24 | l.Fields(map[string]interface{}{"key3": "val4"}).Log(InfoLevel, "test_msg")
25 | }
26 |
27 | func TestExtract(t *testing.T) {
28 | l := NewLogger(WithLevel(TraceLevel), WithCallerSkipCount(2)).Fields(map[string]interface{}{"requestID": "req-1"})
29 |
30 | ctx := NewContext(context.Background(), l)
31 |
32 | Info("info message without request ID")
33 | Extract(ctx).Info("info message with request ID")
34 | }
35 |
--------------------------------------------------------------------------------
/logger/options.go:
--------------------------------------------------------------------------------
1 | package logger
2 |
3 | import (
4 | "context"
5 | "io"
6 | )
7 |
8 | type Option func(*Options)
9 |
10 | type Options struct {
11 | // It's common to set this to a file, or leave it default which is `os.Stderr`
12 | Out io.Writer
13 | // Alternative options
14 | Context context.Context
15 | // fields to always be logged
16 | Fields map[string]interface{}
17 | // Caller skip frame count for file:line info
18 | CallerSkipCount int
19 | // The logging level the logger should log at. default is `InfoLevel`
20 | Level Level
21 | }
22 |
23 | // WithFields set default fields for the logger.
24 | func WithFields(fields map[string]interface{}) Option {
25 | return func(args *Options) {
26 | args.Fields = fields
27 | }
28 | }
29 |
30 | // WithLevel set default level for the logger.
31 | func WithLevel(level Level) Option {
32 | return func(args *Options) {
33 | args.Level = level
34 | }
35 | }
36 |
37 | // WithOutput set default output writer for the logger.
38 | func WithOutput(out io.Writer) Option {
39 | return func(args *Options) {
40 | args.Out = out
41 | }
42 | }
43 |
44 | // WithCallerSkipCount set frame count to skip.
45 | func WithCallerSkipCount(c int) Option {
46 | return func(args *Options) {
47 | args.CallerSkipCount = c
48 | }
49 | }
50 |
51 | func SetOption(k, v interface{}) Option {
52 | return func(o *Options) {
53 | if o.Context == nil {
54 | o.Context = context.Background()
55 | }
56 | o.Context = context.WithValue(o.Context, k, v)
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/micro/go-micro/88f38eaef6cfa46fb7f5c0f13895368e52691768/logo.png
--------------------------------------------------------------------------------
/options.go:
--------------------------------------------------------------------------------
1 | package micro
2 |
3 | import (
4 | "go-micro.dev/v5/service"
5 | )
6 |
7 | var Broker = service.Broker
8 | var Cache = service.Cache
9 | var Cmd = service.Cmd
10 | var Client = service.Client
11 | var Context = service.Context
12 | var Handle = service.Handle
13 | var HandleSignal = service.HandleSignal
14 | var Profile = service.Profile
15 | var Server = service.Server
16 | var Store = service.Store
17 | var Registry = service.Registry
18 | var Tracer = service.Tracer
19 | var Auth = service.Auth
20 | var Config = service.Config
21 | var Selector = service.Selector
22 | var Transport = service.Transport
23 | var Address = service.Address
24 | var Name = service.Name
25 | var Version = service.Version
26 | var Metadata = service.Metadata
27 | var Flags = service.Flags
28 | var Action = service.Action
29 | var RegisterTTL = service.RegisterTTL
30 | var RegisterInterval = service.RegisterInterval
31 | var WrapClient = service.WrapClient
32 | var WrapCall = service.WrapCall
33 | var WrapHandler = service.WrapHandler
34 | var WrapSubscriber = service.WrapSubscriber
35 | var AddListenOption = service.AddListenOption
36 | var BeforeStart = service.BeforeStart
37 | var BeforeStop = service.BeforeStop
38 | var AfterStart = service.AfterStart
39 | var AfterStop = service.AfterStop
40 | var Logger = service.Logger
41 |
--------------------------------------------------------------------------------
/registry/cache/README.md:
--------------------------------------------------------------------------------
1 | # Registry Cache
2 |
3 | Cache is a library that provides a caching layer for the go-micro [registry](https://godoc.org/github.com/micro/go-micro/registry#Registry).
4 |
5 | If you're looking for caching in your microservices use the [selector](https://micro.mu/docs/fault-tolerance.html#caching-discovery).
6 |
7 | ## Interface
8 |
9 | ```go
10 | // Cache is the registry cache interface
11 | type Cache interface {
12 | // embed the registry interface
13 | registry.Registry
14 | // stop the cache watcher
15 | Stop()
16 | }
17 | ```
18 |
19 | ## Usage
20 |
21 | ```go
22 | import (
23 | "github.com/micro/go-micro/registry"
24 | "github.com/micro/go-micro/registry/cache"
25 | )
26 |
27 | r := registry.NewRegistry()
28 | cache := cache.New(r)
29 |
30 | services, _ := cache.GetService("my.service")
31 | ```
32 |
--------------------------------------------------------------------------------
/registry/cache/options.go:
--------------------------------------------------------------------------------
1 | package cache
2 |
3 | import (
4 | "time"
5 |
6 | "go-micro.dev/v5/logger"
7 | )
8 |
9 | // WithTTL sets the cache TTL.
10 | func WithTTL(t time.Duration) Option {
11 | return func(o *Options) {
12 | o.TTL = t
13 | }
14 | }
15 |
16 | // WithLogger sets the underline logger.
17 | func WithLogger(l logger.Logger) Option {
18 | return func(o *Options) {
19 | o.Logger = l
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/registry/etcd/options.go:
--------------------------------------------------------------------------------
1 | package etcd
2 |
3 | import (
4 | "context"
5 |
6 | "go-micro.dev/v5/registry"
7 | "go.uber.org/zap"
8 | )
9 |
10 | type authKey struct{}
11 |
12 | type logConfigKey struct{}
13 |
14 | type authCreds struct {
15 | Username string
16 | Password string
17 | }
18 |
19 | // Auth allows you to specify username/password.
20 | func Auth(username, password string) registry.Option {
21 | return func(o *registry.Options) {
22 | if o.Context == nil {
23 | o.Context = context.Background()
24 | }
25 | o.Context = context.WithValue(o.Context, authKey{}, &authCreds{Username: username, Password: password})
26 | }
27 | }
28 |
29 | // LogConfig allows you to set etcd log config.
30 | func LogConfig(config *zap.Config) registry.Option {
31 | return func(o *registry.Options) {
32 | if o.Context == nil {
33 | o.Context = context.Background()
34 | }
35 | o.Context = context.WithValue(o.Context, logConfigKey{}, config)
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/registry/memory_watcher.go:
--------------------------------------------------------------------------------
1 | package registry
2 |
3 | import (
4 | "errors"
5 | )
6 |
7 | type memWatcher struct {
8 | wo WatchOptions
9 | res chan *Result
10 | exit chan bool
11 | id string
12 | }
13 |
14 | func (m *memWatcher) Next() (*Result, error) {
15 | for {
16 | select {
17 | case r := <-m.res:
18 | if len(m.wo.Service) > 0 && m.wo.Service != r.Service.Name {
19 | continue
20 | }
21 | return r, nil
22 | case <-m.exit:
23 | return nil, errors.New("watcher stopped")
24 | }
25 | }
26 | }
27 |
28 | func (m *memWatcher) Stop() {
29 | select {
30 | case <-m.exit:
31 | return
32 | default:
33 | close(m.exit)
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/registry/nats/nats_assert_test.go:
--------------------------------------------------------------------------------
1 | package nats_test
2 |
3 | import (
4 | "reflect"
5 | "testing"
6 | )
7 |
8 | func assertNoError(tb testing.TB, actual error) {
9 | if actual != nil {
10 | tb.Errorf("expected no error, got %v", actual)
11 | }
12 | }
13 |
14 | func assertEqual(tb testing.TB, expected, actual interface{}) {
15 | if !reflect.DeepEqual(expected, actual) {
16 | tb.Errorf("expected %v, got %v", expected, actual)
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/registry/nats/nats_environment_test.go:
--------------------------------------------------------------------------------
1 | package nats_test
2 |
3 | import (
4 | "os"
5 | "testing"
6 |
7 | log "go-micro.dev/v5/logger"
8 | "go-micro.dev/v5/registry"
9 | "go-micro.dev/v5/registry/nats"
10 | )
11 |
12 | type environment struct {
13 | registryOne registry.Registry
14 | registryTwo registry.Registry
15 | registryThree registry.Registry
16 |
17 | serviceOne registry.Service
18 | serviceTwo registry.Service
19 |
20 | nodeOne registry.Node
21 | nodeTwo registry.Node
22 | nodeThree registry.Node
23 | }
24 |
25 | var e environment
26 |
27 | func TestMain(m *testing.M) {
28 | natsURL := os.Getenv("NATS_URL")
29 | if natsURL == "" {
30 | log.Infof("NATS_URL is undefined - skipping tests")
31 | return
32 | }
33 |
34 | e.registryOne = nats.NewNatsRegistry(registry.Addrs(natsURL), nats.Quorum(1))
35 | e.registryTwo = nats.NewNatsRegistry(registry.Addrs(natsURL), nats.Quorum(1))
36 | e.registryThree = nats.NewNatsRegistry(registry.Addrs(natsURL), nats.Quorum(1))
37 |
38 | e.serviceOne.Name = "one"
39 | e.serviceOne.Version = "default"
40 | e.serviceOne.Nodes = []*registry.Node{&e.nodeOne}
41 |
42 | e.serviceTwo.Name = "two"
43 | e.serviceTwo.Version = "default"
44 | e.serviceTwo.Nodes = []*registry.Node{&e.nodeOne, &e.nodeTwo}
45 |
46 | e.nodeOne.Id = "one"
47 | e.nodeTwo.Id = "two"
48 | e.nodeThree.Id = "three"
49 |
50 | if err := e.registryOne.Register(&e.serviceOne); err != nil {
51 | log.Fatal(err)
52 | }
53 |
54 | if err := e.registryOne.Register(&e.serviceTwo); err != nil {
55 | log.Fatal(err)
56 | }
57 |
58 | result := m.Run()
59 |
60 | if err := e.registryOne.Deregister(&e.serviceOne); err != nil {
61 | log.Fatal(err)
62 | }
63 |
64 | if err := e.registryOne.Deregister(&e.serviceTwo); err != nil {
65 | log.Fatal(err)
66 | }
67 |
68 | os.Exit(result)
69 | }
70 |
--------------------------------------------------------------------------------
/registry/nats/nats_registry.go:
--------------------------------------------------------------------------------
1 | package nats
2 |
3 | var (
4 | DefaultRegistry = NewNatsRegistry()
5 | )
6 |
--------------------------------------------------------------------------------
/registry/nats/nats_watcher.go:
--------------------------------------------------------------------------------
1 | package nats
2 |
3 | import (
4 | "encoding/json"
5 | "time"
6 |
7 | "github.com/nats-io/nats.go"
8 | "go-micro.dev/v5/registry"
9 | )
10 |
11 | type natsWatcher struct {
12 | sub *nats.Subscription
13 | wo registry.WatchOptions
14 | }
15 |
16 | func (n *natsWatcher) Next() (*registry.Result, error) {
17 | var result *registry.Result
18 | for {
19 | m, err := n.sub.NextMsg(time.Minute)
20 | if err != nil && err == nats.ErrTimeout {
21 | continue
22 | } else if err != nil {
23 | return nil, err
24 | }
25 | if err := json.Unmarshal(m.Data, &result); err != nil {
26 | return nil, err
27 | }
28 | if len(n.wo.Service) > 0 && result.Service.Name != n.wo.Service {
29 | continue
30 | }
31 | break
32 | }
33 |
34 | return result, nil
35 | }
36 |
37 | func (n *natsWatcher) Stop() {
38 | n.sub.Unsubscribe()
39 | }
40 |
--------------------------------------------------------------------------------
/registry/watcher.go:
--------------------------------------------------------------------------------
1 | package registry
2 |
3 | import "time"
4 |
5 | // Watcher is an interface that returns updates
6 | // about services within the registry.
7 | type Watcher interface {
8 | // Next is a blocking call
9 | Next() (*Result, error)
10 | Stop()
11 | }
12 |
13 | // Result is returned by a call to Next on
14 | // the watcher. Actions can be create, update, delete.
15 | type Result struct {
16 | Service *Service
17 | Action string
18 | }
19 |
20 | // EventType defines registry event type.
21 | type EventType int
22 |
23 | const (
24 | // Create is emitted when a new service is registered.
25 | Create EventType = iota
26 | // Delete is emitted when an existing service is deregsitered.
27 | Delete
28 | // Update is emitted when an existing servicec is updated.
29 | Update
30 | )
31 |
32 | // String returns human readable event type.
33 | func (t EventType) String() string {
34 | switch t {
35 | case Create:
36 | return "create"
37 | case Delete:
38 | return "delete"
39 | case Update:
40 | return "update"
41 | default:
42 | return "unknown"
43 | }
44 | }
45 |
46 | // Event is registry event.
47 | type Event struct {
48 | // Timestamp is event timestamp
49 | Timestamp time.Time
50 | // Service is registry service
51 | Service *Service
52 | // Id is registry id
53 | Id string
54 | // Type defines type of event
55 | Type EventType
56 | }
57 |
--------------------------------------------------------------------------------
/selector/common_test.go:
--------------------------------------------------------------------------------
1 | package selector
2 |
3 | import (
4 | "go-micro.dev/v5/registry"
5 | )
6 |
7 | var (
8 | // mock data.
9 | testData = map[string][]*registry.Service{
10 | "foo": {
11 | {
12 | Name: "foo",
13 | Version: "1.0.0",
14 | Nodes: []*registry.Node{
15 | {
16 | Id: "foo-1.0.0-123",
17 | Address: "localhost:9999",
18 | },
19 | {
20 | Id: "foo-1.0.0-321",
21 | Address: "localhost:9999",
22 | },
23 | },
24 | },
25 | {
26 | Name: "foo",
27 | Version: "1.0.1",
28 | Nodes: []*registry.Node{
29 | {
30 | Id: "foo-1.0.1-321",
31 | Address: "localhost:6666",
32 | },
33 | },
34 | },
35 | {
36 | Name: "foo",
37 | Version: "1.0.3",
38 | Nodes: []*registry.Node{
39 | {
40 | Id: "foo-1.0.3-345",
41 | Address: "localhost:8888",
42 | },
43 | },
44 | },
45 | },
46 | }
47 | )
48 |
--------------------------------------------------------------------------------
/selector/default_test.go:
--------------------------------------------------------------------------------
1 | package selector
2 |
3 | import (
4 | "os"
5 | "testing"
6 |
7 | "go-micro.dev/v5/registry"
8 | )
9 |
10 | func TestRegistrySelector(t *testing.T) {
11 | counts := map[string]int{}
12 |
13 | r := registry.NewMemoryRegistry(registry.Services(testData))
14 | cache := NewSelector(Registry(r))
15 |
16 | next, err := cache.Select("foo")
17 | if err != nil {
18 | t.Errorf("Unexpected error calling cache select: %v", err)
19 | }
20 |
21 | for i := 0; i < 100; i++ {
22 | node, err := next()
23 | if err != nil {
24 | t.Errorf("Expected node err, got err: %v", err)
25 | }
26 | counts[node.Id]++
27 | }
28 |
29 | if len(os.Getenv("IN_TRAVIS_CI")) == 0 {
30 | t.Logf("Selector Counts %v", counts)
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/selector/filter.go:
--------------------------------------------------------------------------------
1 | package selector
2 |
3 | import (
4 | "go-micro.dev/v5/registry"
5 | )
6 |
7 | // FilterEndpoint is an endpoint based Select Filter which will
8 | // only return services with the endpoint specified.
9 | func FilterEndpoint(name string) Filter {
10 | return func(old []*registry.Service) []*registry.Service {
11 | var services []*registry.Service
12 |
13 | for _, service := range old {
14 | for _, ep := range service.Endpoints {
15 | if ep.Name == name {
16 | services = append(services, service)
17 | break
18 | }
19 | }
20 | }
21 |
22 | return services
23 | }
24 | }
25 |
26 | // FilterLabel is a label based Select Filter which will
27 | // only return services with the label specified.
28 | func FilterLabel(key, val string) Filter {
29 | return func(old []*registry.Service) []*registry.Service {
30 | var services []*registry.Service
31 |
32 | for _, service := range old {
33 | serv := new(registry.Service)
34 | var nodes []*registry.Node
35 |
36 | for _, node := range service.Nodes {
37 | if node.Metadata == nil {
38 | continue
39 | }
40 |
41 | if node.Metadata[key] == val {
42 | nodes = append(nodes, node)
43 | }
44 | }
45 |
46 | // only add service if there's some nodes
47 | if len(nodes) > 0 {
48 | // copy
49 | *serv = *service
50 | serv.Nodes = nodes
51 | services = append(services, serv)
52 | }
53 | }
54 |
55 | return services
56 | }
57 | }
58 |
59 | // FilterVersion is a version based Select Filter which will
60 | // only return services with the version specified.
61 | func FilterVersion(version string) Filter {
62 | return func(old []*registry.Service) []*registry.Service {
63 | var services []*registry.Service
64 |
65 | for _, service := range old {
66 | if service.Version == version {
67 | services = append(services, service)
68 | }
69 | }
70 |
71 | return services
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/selector/options.go:
--------------------------------------------------------------------------------
1 | package selector
2 |
3 | import (
4 | "context"
5 |
6 | "go-micro.dev/v5/logger"
7 | "go-micro.dev/v5/registry"
8 | )
9 |
10 | type Options struct {
11 | Registry registry.Registry
12 | Strategy Strategy
13 |
14 | // Other options for implementations of the interface
15 | // can be stored in a context
16 | Context context.Context
17 | // Logger is the underline logger
18 | Logger logger.Logger
19 | }
20 |
21 | type SelectOptions struct {
22 |
23 | // Other options for implementations of the interface
24 | // can be stored in a context
25 | Context context.Context
26 | Strategy Strategy
27 |
28 | Filters []Filter
29 | }
30 |
31 | type Option func(*Options)
32 |
33 | // SelectOption used when making a select call.
34 | type SelectOption func(*SelectOptions)
35 |
36 | // Registry sets the registry used by the selector.
37 | func Registry(r registry.Registry) Option {
38 | return func(o *Options) {
39 | o.Registry = r
40 | }
41 | }
42 |
43 | // SetStrategy sets the default strategy for the selector.
44 | func SetStrategy(fn Strategy) Option {
45 | return func(o *Options) {
46 | o.Strategy = fn
47 | }
48 | }
49 |
50 | // WithFilter adds a filter function to the list of filters
51 | // used during the Select call.
52 | func WithFilter(fn ...Filter) SelectOption {
53 | return func(o *SelectOptions) {
54 | o.Filters = append(o.Filters, fn...)
55 | }
56 | }
57 |
58 | // Strategy sets the selector strategy.
59 | func WithStrategy(fn Strategy) SelectOption {
60 | return func(o *SelectOptions) {
61 | o.Strategy = fn
62 | }
63 | }
64 |
65 | // WithLogger sets the underline logger.
66 | func WithLogger(l logger.Logger) Option {
67 | return func(o *Options) {
68 | o.Logger = l
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/selector/selector.go:
--------------------------------------------------------------------------------
1 | // Package selector is a way to pick a list of service nodes
2 | package selector
3 |
4 | import (
5 | "errors"
6 |
7 | "go-micro.dev/v5/registry"
8 | )
9 |
10 | // Selector builds on the registry as a mechanism to pick nodes
11 | // and mark their status. This allows host pools and other things
12 | // to be built using various algorithms.
13 | type Selector interface {
14 | Init(opts ...Option) error
15 | Options() Options
16 | // Select returns a function which should return the next node
17 | Select(service string, opts ...SelectOption) (Next, error)
18 | // Mark sets the success/error against a node
19 | Mark(service string, node *registry.Node, err error)
20 | // Reset returns state back to zero for a service
21 | Reset(service string)
22 | // Close renders the selector unusable
23 | Close() error
24 | // Name of the selector
25 | String() string
26 | }
27 |
28 | // Next is a function that returns the next node
29 | // based on the selector's strategy.
30 | type Next func() (*registry.Node, error)
31 |
32 | // Filter is used to filter a service during the selection process.
33 | type Filter func([]*registry.Service) []*registry.Service
34 |
35 | // Strategy is a selection strategy e.g random, round robin.
36 | type Strategy func([]*registry.Service) Next
37 |
38 | var (
39 | DefaultSelector = NewSelector()
40 |
41 | ErrNotFound = errors.New("not found")
42 | ErrNoneAvailable = errors.New("none available")
43 | )
44 |
--------------------------------------------------------------------------------
/selector/strategy.go:
--------------------------------------------------------------------------------
1 | package selector
2 |
3 | import (
4 | "math/rand"
5 | "sync"
6 | "time"
7 |
8 | "go-micro.dev/v5/registry"
9 | )
10 |
11 | func init() {
12 | rand.Seed(time.Now().UnixNano())
13 | }
14 |
15 | // Random is a random strategy algorithm for node selection.
16 | func Random(services []*registry.Service) Next {
17 | nodes := make([]*registry.Node, 0, len(services))
18 |
19 | for _, service := range services {
20 | nodes = append(nodes, service.Nodes...)
21 | }
22 |
23 | return func() (*registry.Node, error) {
24 | if len(nodes) == 0 {
25 | return nil, ErrNoneAvailable
26 | }
27 |
28 | i := rand.Int() % len(nodes)
29 | return nodes[i], nil
30 | }
31 | }
32 |
33 | // RoundRobin is a roundrobin strategy algorithm for node selection.
34 | func RoundRobin(services []*registry.Service) Next {
35 | nodes := make([]*registry.Node, 0, len(services))
36 |
37 | for _, service := range services {
38 | nodes = append(nodes, service.Nodes...)
39 | }
40 |
41 | var i = rand.Int()
42 | var mtx sync.Mutex
43 |
44 | return func() (*registry.Node, error) {
45 | if len(nodes) == 0 {
46 | return nil, ErrNoneAvailable
47 | }
48 |
49 | mtx.Lock()
50 | node := nodes[i%len(nodes)]
51 | i++
52 | mtx.Unlock()
53 |
54 | return node, nil
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/selector/strategy_test.go:
--------------------------------------------------------------------------------
1 | package selector
2 |
3 | import (
4 | "os"
5 | "testing"
6 |
7 | "go-micro.dev/v5/registry"
8 | )
9 |
10 | func TestStrategies(t *testing.T) {
11 | testData := []*registry.Service{
12 | {
13 | Name: "test1",
14 | Version: "latest",
15 | Nodes: []*registry.Node{
16 | {
17 | Id: "test1-1",
18 | Address: "10.0.0.1:1001",
19 | },
20 | {
21 | Id: "test1-2",
22 | Address: "10.0.0.2:1002",
23 | },
24 | },
25 | },
26 | {
27 | Name: "test1",
28 | Version: "default",
29 | Nodes: []*registry.Node{
30 | {
31 | Id: "test1-3",
32 | Address: "10.0.0.3:1003",
33 | },
34 | {
35 | Id: "test1-4",
36 | Address: "10.0.0.4:1004",
37 | },
38 | },
39 | },
40 | }
41 |
42 | for name, strategy := range map[string]Strategy{"random": Random, "roundrobin": RoundRobin} {
43 | next := strategy(testData)
44 | counts := make(map[string]int)
45 |
46 | for i := 0; i < 100; i++ {
47 | node, err := next()
48 | if err != nil {
49 | t.Fatal(err)
50 | }
51 | counts[node.Id]++
52 | }
53 |
54 | if len(os.Getenv("IN_TRAVIS_CI")) == 0 {
55 | t.Logf("%s: %+v\n", name, counts)
56 | }
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/server/context.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "context"
5 | "sync"
6 | )
7 |
8 | type serverKey struct{}
9 | type wgKey struct{}
10 |
11 | func wait(ctx context.Context) *sync.WaitGroup {
12 | if ctx == nil {
13 | return nil
14 | }
15 | wg, ok := ctx.Value(wgKey{}).(*sync.WaitGroup)
16 | if !ok {
17 | return nil
18 | }
19 | return wg
20 | }
21 |
22 | func FromContext(ctx context.Context) (Server, bool) {
23 | c, ok := ctx.Value(serverKey{}).(Server)
24 | return c, ok
25 | }
26 |
27 | func NewContext(ctx context.Context, s Server) context.Context {
28 | return context.WithValue(ctx, serverKey{}, s)
29 | }
30 |
--------------------------------------------------------------------------------
/server/extractor_test.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "context"
5 | "reflect"
6 | "testing"
7 |
8 | "go-micro.dev/v5/registry"
9 | )
10 |
11 | type testHandler struct{}
12 |
13 | type testRequest struct{}
14 |
15 | type testResponse struct{}
16 |
17 | func (t *testHandler) Test(ctx context.Context, req *testRequest, rsp *testResponse) error {
18 | return nil
19 | }
20 |
21 | func TestExtractEndpoint(t *testing.T) {
22 | handler := &testHandler{}
23 | typ := reflect.TypeOf(handler)
24 |
25 | var endpoints []*registry.Endpoint
26 |
27 | for m := 0; m < typ.NumMethod(); m++ {
28 | if e := extractEndpoint(typ.Method(m)); e != nil {
29 | endpoints = append(endpoints, e)
30 | }
31 | }
32 |
33 | if i := len(endpoints); i != 1 {
34 | t.Errorf("Expected 1 endpoint, have %d", i)
35 | }
36 |
37 | if endpoints[0].Name != "Test" {
38 | t.Errorf("Expected handler Test, got %s", endpoints[0].Name)
39 | }
40 |
41 | if endpoints[0].Request == nil {
42 | t.Error("Expected non nil request")
43 | }
44 |
45 | if endpoints[0].Response == nil {
46 | t.Error("Expected non nil request")
47 | }
48 |
49 | if endpoints[0].Request.Name != "testRequest" {
50 | t.Errorf("Expected testRequest got %s", endpoints[0].Request.Name)
51 | }
52 |
53 | if endpoints[0].Response.Name != "testResponse" {
54 | t.Errorf("Expected testResponse got %s", endpoints[0].Response.Name)
55 | }
56 |
57 | if endpoints[0].Request.Type != "testRequest" {
58 | t.Errorf("Expected testRequest type got %s", endpoints[0].Request.Type)
59 | }
60 |
61 | if endpoints[0].Response.Type != "testResponse" {
62 | t.Errorf("Expected testResponse type got %s", endpoints[0].Response.Type)
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/server/grpc/context.go:
--------------------------------------------------------------------------------
1 | package grpc
2 |
3 | import (
4 | "context"
5 |
6 | "go-micro.dev/v5/server"
7 | )
8 |
9 | func setServerOption(k, v interface{}) server.Option {
10 | return func(o *server.Options) {
11 | if o.Context == nil {
12 | o.Context = context.Background()
13 | }
14 | o.Context = context.WithValue(o.Context, k, v)
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/server/grpc/error.go:
--------------------------------------------------------------------------------
1 | package grpc
2 |
3 | import (
4 | "net/http"
5 |
6 | "go-micro.dev/v5/errors"
7 | "google.golang.org/grpc/codes"
8 | )
9 |
10 | func microError(err *errors.Error) codes.Code {
11 | switch err {
12 | case nil:
13 | return codes.OK
14 | }
15 |
16 | switch err.Code {
17 | case http.StatusOK:
18 | return codes.OK
19 | case http.StatusBadRequest:
20 | return codes.InvalidArgument
21 | case http.StatusRequestTimeout:
22 | return codes.DeadlineExceeded
23 | case http.StatusNotFound:
24 | return codes.NotFound
25 | case http.StatusConflict:
26 | return codes.AlreadyExists
27 | case http.StatusForbidden:
28 | return codes.PermissionDenied
29 | case http.StatusUnauthorized:
30 | return codes.Unauthenticated
31 | case http.StatusPreconditionFailed:
32 | return codes.FailedPrecondition
33 | case http.StatusNotImplemented:
34 | return codes.Unimplemented
35 | case http.StatusInternalServerError:
36 | return codes.Internal
37 | case http.StatusServiceUnavailable:
38 | return codes.Unavailable
39 | }
40 |
41 | return codes.Unknown
42 | }
43 |
--------------------------------------------------------------------------------
/server/grpc/extractor_test.go:
--------------------------------------------------------------------------------
1 | package grpc
2 |
3 | import (
4 | "context"
5 | "reflect"
6 | "testing"
7 |
8 | "go-micro.dev/v5/registry"
9 | )
10 |
11 | type testHandler struct{}
12 |
13 | type testRequest struct{}
14 |
15 | type testResponse struct{}
16 |
17 | func (t *testHandler) Test(ctx context.Context, req *testRequest, rsp *testResponse) error {
18 | return nil
19 | }
20 |
21 | func TestExtractEndpoint(t *testing.T) {
22 | handler := &testHandler{}
23 | typ := reflect.TypeOf(handler)
24 |
25 | var endpoints []*registry.Endpoint
26 |
27 | for m := 0; m < typ.NumMethod(); m++ {
28 | if e := extractEndpoint(typ.Method(m)); e != nil {
29 | endpoints = append(endpoints, e)
30 | }
31 | }
32 |
33 | if i := len(endpoints); i != 1 {
34 | t.Errorf("Expected 1 endpoint, have %d", i)
35 | }
36 |
37 | if endpoints[0].Name != "Test" {
38 | t.Errorf("Expected handler Test, got %s", endpoints[0].Name)
39 | }
40 |
41 | if endpoints[0].Request == nil {
42 | t.Error("Expected non nil request")
43 | }
44 |
45 | if endpoints[0].Response == nil {
46 | t.Error("Expected non nil request")
47 | }
48 |
49 | if endpoints[0].Request.Name != "testRequest" {
50 | t.Errorf("Expected testRequest got %s", endpoints[0].Request.Name)
51 | }
52 |
53 | if endpoints[0].Response.Name != "testResponse" {
54 | t.Errorf("Expected testResponse got %s", endpoints[0].Response.Name)
55 | }
56 |
57 | if endpoints[0].Request.Type != "testRequest" {
58 | t.Errorf("Expected testRequest type got %s", endpoints[0].Request.Type)
59 | }
60 |
61 | if endpoints[0].Response.Type != "testResponse" {
62 | t.Errorf("Expected testResponse type got %s", endpoints[0].Response.Type)
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/server/grpc/handler.go:
--------------------------------------------------------------------------------
1 | package grpc
2 |
3 | import (
4 | "reflect"
5 |
6 | "go-micro.dev/v5/registry"
7 | "go-micro.dev/v5/server"
8 | )
9 |
10 | type rpcHandler struct {
11 | name string
12 | handler interface{}
13 | endpoints []*registry.Endpoint
14 | opts server.HandlerOptions
15 | }
16 |
17 | func newRpcHandler(handler interface{}, opts ...server.HandlerOption) server.Handler {
18 | options := server.HandlerOptions{
19 | Metadata: make(map[string]map[string]string),
20 | }
21 |
22 | for _, o := range opts {
23 | o(&options)
24 | }
25 |
26 | typ := reflect.TypeOf(handler)
27 | hdlr := reflect.ValueOf(handler)
28 | name := reflect.Indirect(hdlr).Type().Name()
29 |
30 | var endpoints []*registry.Endpoint
31 |
32 | for m := 0; m < typ.NumMethod(); m++ {
33 | if e := extractEndpoint(typ.Method(m)); e != nil {
34 | e.Name = name + "." + e.Name
35 |
36 | for k, v := range options.Metadata[e.Name] {
37 | e.Metadata[k] = v
38 | }
39 |
40 | endpoints = append(endpoints, e)
41 | }
42 | }
43 |
44 | return &rpcHandler{
45 | name: name,
46 | handler: handler,
47 | endpoints: endpoints,
48 | opts: options,
49 | }
50 | }
51 |
52 | func (r *rpcHandler) Name() string {
53 | return r.name
54 | }
55 |
56 | func (r *rpcHandler) Handler() interface{} {
57 | return r.handler
58 | }
59 |
60 | func (r *rpcHandler) Endpoints() []*registry.Endpoint {
61 | return r.endpoints
62 | }
63 |
64 | func (r *rpcHandler) Options() server.HandlerOptions {
65 | return r.opts
66 | }
67 |
--------------------------------------------------------------------------------
/server/grpc/request.go:
--------------------------------------------------------------------------------
1 | package grpc
2 |
3 | import (
4 | "go-micro.dev/v5/codec"
5 | "go-micro.dev/v5/codec/bytes"
6 | )
7 |
8 | type rpcRequest struct {
9 | service string
10 | method string
11 | contentType string
12 | codec codec.Codec
13 | header map[string]string
14 | body []byte
15 | stream bool
16 | payload interface{}
17 | }
18 |
19 | type rpcMessage struct {
20 | topic string
21 | contentType string
22 | payload interface{}
23 | header map[string]string
24 | body []byte
25 | codec codec.Codec
26 | }
27 |
28 | func (r *rpcRequest) ContentType() string {
29 | return r.contentType
30 | }
31 |
32 | func (r *rpcRequest) Service() string {
33 | return r.service
34 | }
35 |
36 | func (r *rpcRequest) Method() string {
37 | return r.method
38 | }
39 |
40 | func (r *rpcRequest) Endpoint() string {
41 | return r.method
42 | }
43 |
44 | func (r *rpcRequest) Codec() codec.Reader {
45 | return r.codec
46 | }
47 |
48 | func (r *rpcRequest) Header() map[string]string {
49 | return r.header
50 | }
51 |
52 | func (r *rpcRequest) Read() ([]byte, error) {
53 | f := &bytes.Frame{}
54 | if err := r.codec.ReadBody(f); err != nil {
55 | return nil, err
56 | }
57 | return f.Data, nil
58 | }
59 |
60 | func (r *rpcRequest) Stream() bool {
61 | return r.stream
62 | }
63 |
64 | func (r *rpcRequest) Body() interface{} {
65 | return r.payload
66 | }
67 |
68 | func (r *rpcMessage) ContentType() string {
69 | return r.contentType
70 | }
71 |
72 | func (r *rpcMessage) Topic() string {
73 | return r.topic
74 | }
75 |
76 | func (r *rpcMessage) Payload() interface{} {
77 | return r.payload
78 | }
79 |
80 | func (r *rpcMessage) Header() map[string]string {
81 | return r.header
82 | }
83 |
84 | func (r *rpcMessage) Body() []byte {
85 | return r.body
86 | }
87 |
88 | func (r *rpcMessage) Codec() codec.Reader {
89 | return r.codec
90 | }
91 |
--------------------------------------------------------------------------------
/server/grpc/response.go:
--------------------------------------------------------------------------------
1 | package grpc
2 |
3 | import (
4 | "go-micro.dev/v5/codec"
5 | )
6 |
7 | type rpcResponse struct {
8 | header map[string]string
9 | codec codec.Codec
10 | }
11 |
12 | func (r *rpcResponse) Codec() codec.Writer {
13 | return r.codec
14 | }
15 |
16 | func (r *rpcResponse) WriteHeader(hdr map[string]string) {
17 | for k, v := range hdr {
18 | r.header[k] = v
19 | }
20 | }
21 |
22 | func (r *rpcResponse) Write(b []byte) error {
23 | return r.codec.Write(&codec.Message{
24 | Header: r.header,
25 | Body: b,
26 | }, nil)
27 | }
28 |
--------------------------------------------------------------------------------
/server/grpc/stream.go:
--------------------------------------------------------------------------------
1 | package grpc
2 |
3 | import (
4 | "context"
5 |
6 | "go-micro.dev/v5/server"
7 | "google.golang.org/grpc"
8 | )
9 |
10 | // rpcStream implements a server side Stream.
11 | type rpcStream struct {
12 | s grpc.ServerStream
13 | request server.Request
14 | }
15 |
16 | func (r *rpcStream) Close() error {
17 | return nil
18 | }
19 |
20 | func (r *rpcStream) Error() error {
21 | return nil
22 | }
23 |
24 | func (r *rpcStream) Request() server.Request {
25 | return r.request
26 | }
27 |
28 | func (r *rpcStream) Context() context.Context {
29 | return r.s.Context()
30 | }
31 |
32 | func (r *rpcStream) Send(m interface{}) error {
33 | return r.s.SendMsg(m)
34 | }
35 |
36 | func (r *rpcStream) Recv(m interface{}) error {
37 | return r.s.RecvMsg(m)
38 | }
39 |
--------------------------------------------------------------------------------
/server/grpc/util.go:
--------------------------------------------------------------------------------
1 | package grpc
2 |
3 | import (
4 | "context"
5 | "io"
6 | "os"
7 | "sync"
8 |
9 | "google.golang.org/grpc/codes"
10 | )
11 |
12 | // convertCode converts a standard Go error into its canonical code. Note that
13 | // this is only used to translate the error returned by the server applications.
14 | func convertCode(err error) codes.Code {
15 | switch err {
16 | case nil:
17 | return codes.OK
18 | case io.EOF:
19 | return codes.OutOfRange
20 | case io.ErrClosedPipe, io.ErrNoProgress, io.ErrShortBuffer, io.ErrShortWrite, io.ErrUnexpectedEOF:
21 | return codes.FailedPrecondition
22 | case os.ErrInvalid:
23 | return codes.InvalidArgument
24 | case context.Canceled:
25 | return codes.Canceled
26 | case context.DeadlineExceeded:
27 | return codes.DeadlineExceeded
28 | }
29 | switch {
30 | case os.IsExist(err):
31 | return codes.AlreadyExists
32 | case os.IsNotExist(err):
33 | return codes.NotFound
34 | case os.IsPermission(err):
35 | return codes.PermissionDenied
36 | }
37 | return codes.Unknown
38 | }
39 |
40 | func wait(ctx context.Context) *sync.WaitGroup {
41 | if ctx == nil {
42 | return nil
43 | }
44 | wg, ok := ctx.Value("wait").(*sync.WaitGroup)
45 | if !ok {
46 | return nil
47 | }
48 | return wg
49 | }
50 |
--------------------------------------------------------------------------------
/server/mock/mock_handler.go:
--------------------------------------------------------------------------------
1 | package mock
2 |
3 | import (
4 | "go-micro.dev/v5/registry"
5 | "go-micro.dev/v5/server"
6 | )
7 |
8 | type MockHandler struct {
9 | Opts server.HandlerOptions
10 | Hdlr interface{}
11 | Id string
12 | }
13 |
14 | func (m *MockHandler) Name() string {
15 | return m.Id
16 | }
17 |
18 | func (m *MockHandler) Handler() interface{} {
19 | return m.Hdlr
20 | }
21 |
22 | func (m *MockHandler) Endpoints() []*registry.Endpoint {
23 | return []*registry.Endpoint{}
24 | }
25 |
26 | func (m *MockHandler) Options() server.HandlerOptions {
27 | return m.Opts
28 | }
29 |
--------------------------------------------------------------------------------
/server/mock/mock_subscriber.go:
--------------------------------------------------------------------------------
1 | package mock
2 |
3 | import (
4 | "go-micro.dev/v5/registry"
5 | "go-micro.dev/v5/server"
6 | )
7 |
8 | type MockSubscriber struct {
9 | Opts server.SubscriberOptions
10 | Sub interface{}
11 | Id string
12 | }
13 |
14 | func (m *MockSubscriber) Topic() string {
15 | return m.Id
16 | }
17 |
18 | func (m *MockSubscriber) Subscriber() interface{} {
19 | return m.Sub
20 | }
21 |
22 | func (m *MockSubscriber) Endpoints() []*registry.Endpoint {
23 | return []*registry.Endpoint{}
24 | }
25 |
26 | func (m *MockSubscriber) Options() server.SubscriberOptions {
27 | return m.Opts
28 | }
29 |
--------------------------------------------------------------------------------
/server/mock/mock_test.go:
--------------------------------------------------------------------------------
1 | package mock
2 |
3 | import (
4 | "testing"
5 |
6 | "go-micro.dev/v5/server"
7 | )
8 |
9 | func TestMockServer(t *testing.T) {
10 | srv := NewServer(
11 | server.Name("mock"),
12 | server.Version("latest"),
13 | )
14 |
15 | if srv.Options().Name != "mock" {
16 | t.Fatalf("Expected name mock, got %s", srv.Options().Name)
17 | }
18 |
19 | if srv.Options().Version != "latest" {
20 | t.Fatalf("Expected version latest, got %s", srv.Options().Version)
21 | }
22 |
23 | srv.Init(server.Version("test"))
24 | if srv.Options().Version != "test" {
25 | t.Fatalf("Expected version test, got %s", srv.Options().Version)
26 | }
27 |
28 | h := srv.NewHandler(func() string { return "foo" })
29 | if err := srv.Handle(h); err != nil {
30 | t.Fatal(err)
31 | }
32 |
33 | sub := srv.NewSubscriber("test", func() string { return "foo" })
34 | if err := srv.Subscribe(sub); err != nil {
35 | t.Fatal(err)
36 | }
37 |
38 | if sub.Topic() != "test" {
39 | t.Fatalf("Expected topic test got %s", sub.Topic())
40 | }
41 |
42 | if err := srv.Start(); err != nil {
43 | t.Fatal(err)
44 | }
45 |
46 | if err := srv.Register(); err != nil {
47 | t.Fatal(err)
48 | }
49 |
50 | if err := srv.Deregister(); err != nil {
51 | t.Fatal(err)
52 | }
53 |
54 | if err := srv.Stop(); err != nil {
55 | t.Fatal(err)
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/server/proto/server.proto:
--------------------------------------------------------------------------------
1 | syntax = "proto3";
2 |
3 | package go.micro.server;
4 |
5 | service Server {
6 | rpc Handle(HandleRequest) returns (HandleResponse) {};
7 | rpc Subscribe(SubscribeRequest) returns (SubscribeResponse) {};
8 | }
9 |
10 | message HandleRequest {
11 | string service = 1;
12 | string endpoint = 2;
13 | string protocol = 3;
14 | }
15 |
16 | message HandleResponse {}
17 |
18 | message SubscribeRequest {
19 | string topic = 1;
20 | }
21 |
22 | message SubscribeResponse {}
23 |
--------------------------------------------------------------------------------
/server/rpc_event.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "go-micro.dev/v5/broker"
5 | "go-micro.dev/v5/transport"
6 | "go-micro.dev/v5/transport/headers"
7 | )
8 |
9 | // event is a broker event we handle on the server transport.
10 | type event struct {
11 | err error
12 | message *broker.Message
13 | }
14 |
15 | func (e *event) Ack() error {
16 | // there is no ack support
17 | return nil
18 | }
19 |
20 | func (e *event) Message() *broker.Message {
21 | return e.message
22 | }
23 |
24 | func (e *event) Error() error {
25 | return e.err
26 | }
27 |
28 | func (e *event) Topic() string {
29 | return e.message.Header[headers.Message]
30 | }
31 |
32 | func newEvent(msg transport.Message) *event {
33 | return &event{
34 | message: &broker.Message{
35 | Header: msg.Header,
36 | Body: msg.Body,
37 | },
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/server/rpc_handler.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "reflect"
5 |
6 | "go-micro.dev/v5/registry"
7 | )
8 |
9 | type RpcHandler struct {
10 | handler interface{}
11 | opts HandlerOptions
12 | name string
13 | endpoints []*registry.Endpoint
14 | }
15 |
16 | func NewRpcHandler(handler interface{}, opts ...HandlerOption) Handler {
17 | options := HandlerOptions{
18 | Metadata: make(map[string]map[string]string),
19 | }
20 |
21 | for _, o := range opts {
22 | o(&options)
23 | }
24 |
25 | typ := reflect.TypeOf(handler)
26 | hdlr := reflect.ValueOf(handler)
27 | name := reflect.Indirect(hdlr).Type().Name()
28 |
29 | var endpoints []*registry.Endpoint
30 |
31 | for m := 0; m < typ.NumMethod(); m++ {
32 | if e := extractEndpoint(typ.Method(m)); e != nil {
33 | e.Name = name + "." + e.Name
34 |
35 | for k, v := range options.Metadata[e.Name] {
36 | e.Metadata[k] = v
37 | }
38 |
39 | endpoints = append(endpoints, e)
40 | }
41 | }
42 |
43 | return &RpcHandler{
44 | name: name,
45 | handler: handler,
46 | endpoints: endpoints,
47 | opts: options,
48 | }
49 | }
50 |
51 | func (r *RpcHandler) Name() string {
52 | return r.name
53 | }
54 |
55 | func (r *RpcHandler) Handler() interface{} {
56 | return r.handler
57 | }
58 |
59 | func (r *RpcHandler) Endpoints() []*registry.Endpoint {
60 | return r.endpoints
61 | }
62 |
63 | func (r *RpcHandler) Options() HandlerOptions {
64 | return r.opts
65 | }
66 |
--------------------------------------------------------------------------------
/server/rpc_response.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "net/http"
5 |
6 | "go-micro.dev/v5/codec"
7 | "go-micro.dev/v5/transport"
8 | )
9 |
10 | type rpcResponse struct {
11 | header map[string]string
12 | socket transport.Socket
13 | codec codec.Codec
14 | }
15 |
16 | func (r *rpcResponse) Codec() codec.Writer {
17 | return r.codec
18 | }
19 |
20 | func (r *rpcResponse) WriteHeader(hdr map[string]string) {
21 | for k, v := range hdr {
22 | r.header[k] = v
23 | }
24 | }
25 |
26 | func (r *rpcResponse) Write(b []byte) error {
27 | if _, ok := r.header["Content-Type"]; !ok {
28 | r.header["Content-Type"] = http.DetectContentType(b)
29 | }
30 |
31 | return r.socket.Send(&transport.Message{
32 | Header: r.header,
33 | Body: b,
34 | })
35 | }
36 |
--------------------------------------------------------------------------------
/server/rpc_util.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "sync"
5 | )
6 |
7 | // waitgroup for global management of connections.
8 | type waitGroup struct {
9 | // global waitgroup
10 | gg *sync.WaitGroup
11 | // local waitgroup
12 | lg sync.WaitGroup
13 | }
14 |
15 | // NewWaitGroup returns a new double waitgroup for global management of processes.
16 | func NewWaitGroup(gWg *sync.WaitGroup) *waitGroup {
17 | return &waitGroup{
18 | gg: gWg,
19 | }
20 | }
21 |
22 | func (w *waitGroup) Add(i int) {
23 | w.lg.Add(i)
24 | if w.gg != nil {
25 | w.gg.Add(i)
26 | }
27 | }
28 |
29 | func (w *waitGroup) Done() {
30 | w.lg.Done()
31 | if w.gg != nil {
32 | w.gg.Done()
33 | }
34 | }
35 |
36 | func (w *waitGroup) Wait() {
37 | // only wait on local group
38 | w.lg.Wait()
39 | }
40 |
--------------------------------------------------------------------------------
/server/wrapper.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "context"
5 | )
6 |
7 | // HandlerFunc represents a single method of a handler. It's used primarily
8 | // for the wrappers. What's handed to the actual method is the concrete
9 | // request and response types.
10 | type HandlerFunc func(ctx context.Context, req Request, rsp interface{}) error
11 |
12 | // SubscriberFunc represents a single method of a subscriber. It's used primarily
13 | // for the wrappers. What's handed to the actual method is the concrete
14 | // publication message.
15 | type SubscriberFunc func(ctx context.Context, msg Message) error
16 |
17 | // HandlerWrapper wraps the HandlerFunc and returns the equivalent.
18 | type HandlerWrapper func(HandlerFunc) HandlerFunc
19 |
20 | // SubscriberWrapper wraps the SubscriberFunc and returns the equivalent.
21 | type SubscriberWrapper func(SubscriberFunc) SubscriberFunc
22 |
23 | // StreamWrapper wraps a Stream interface and returns the equivalent.
24 | // Because streams exist for the lifetime of a method invocation this
25 | // is a convenient way to wrap a Stream as its in use for trace, monitoring,
26 | // metrics, etc.
27 | type StreamWrapper func(Stream) Stream
28 |
--------------------------------------------------------------------------------
/store/mysql/mysql_test.go:
--------------------------------------------------------------------------------
1 | //go:build integration
2 | // +build integration
3 |
4 | package mysql
5 |
6 | import (
7 | "encoding/json"
8 | "os"
9 | "testing"
10 | "time"
11 |
12 | _ "github.com/go-sql-driver/mysql"
13 | "go-micro.dev/v5/store"
14 | )
15 |
16 | var (
17 | sqlStoreT store.Store
18 | )
19 |
20 | func TestMain(m *testing.M) {
21 | if tr := os.Getenv("TRAVIS"); len(tr) > 0 {
22 | os.Exit(0)
23 | }
24 |
25 | sqlStoreT = NewMysqlStore(
26 | store.Database("testMicro"),
27 | store.Nodes("root:123@(127.0.0.1:3306)/test?charset=utf8&parseTime=true&loc=Asia%2FShanghai"),
28 | )
29 | os.Exit(m.Run())
30 | }
31 |
32 | func TestWrite(t *testing.T) {
33 | err := sqlStoreT.Write(
34 | &store.Record{
35 | Key: "test",
36 | Value: []byte("foo2"),
37 | Expiry: time.Second * 200,
38 | },
39 | )
40 | if err != nil {
41 | t.Error(err)
42 | }
43 | }
44 |
45 | func TestDelete(t *testing.T) {
46 | err := sqlStoreT.Delete("test")
47 | if err != nil {
48 | t.Error(err)
49 | }
50 | }
51 |
52 | func TestRead(t *testing.T) {
53 | records, err := sqlStoreT.Read("test")
54 | if err != nil {
55 | t.Error(err)
56 | }
57 |
58 | t.Log(string(records[0].Value))
59 | }
60 |
61 | func TestList(t *testing.T) {
62 | records, err := sqlStoreT.List()
63 | if err != nil {
64 | t.Error(err)
65 | } else {
66 | beauty, _ := json.Marshal(records)
67 | t.Log(string(beauty))
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/store/nats-js-kv/context.go:
--------------------------------------------------------------------------------
1 | package natsjskv
2 |
3 | import (
4 | "context"
5 |
6 | "go-micro.dev/v5/store"
7 | )
8 |
9 | // setStoreOption returns a function to setup a context with given value.
10 | func setStoreOption(k, v interface{}) store.Option {
11 | return func(o *store.Options) {
12 | if o.Context == nil {
13 | o.Context = context.Background()
14 | }
15 |
16 | o.Context = context.WithValue(o.Context, k, v)
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/store/noop.go:
--------------------------------------------------------------------------------
1 | package store
2 |
3 | type noopStore struct{}
4 |
5 | func (n *noopStore) Init(opts ...Option) error {
6 | return nil
7 | }
8 |
9 | func (n *noopStore) Options() Options {
10 | return Options{}
11 | }
12 |
13 | func (n *noopStore) String() string {
14 | return "noop"
15 | }
16 |
17 | func (n *noopStore) Read(key string, opts ...ReadOption) ([]*Record, error) {
18 | return []*Record{}, nil
19 | }
20 |
21 | func (n *noopStore) Write(r *Record, opts ...WriteOption) error {
22 | return nil
23 | }
24 |
25 | func (n *noopStore) Delete(key string, opts ...DeleteOption) error {
26 | return nil
27 | }
28 |
29 | func (n *noopStore) List(opts ...ListOption) ([]string, error) {
30 | return []string{}, nil
31 | }
32 |
33 | func (n *noopStore) Close() error {
34 | return nil
35 | }
36 |
37 | func NewNoopStore(opts ...Option) Store {
38 | return new(noopStore)
39 | }
40 |
--------------------------------------------------------------------------------
/store/postgres/README.md:
--------------------------------------------------------------------------------
1 | # Postgres plugin
2 |
3 | This module implements a Postgres implementation of the micro store interface.
4 |
5 | ## Implementation notes
6 |
7 | ### Concepts
8 | We maintain a single connection to the Postgres server. Due to the way connections are handled this means that all micro "databases" and "tables" are stored under a single Postgres database as specified in the connection string (https://www.postgresql.org/docs/8.1/ddl-schemas.html). The mapping of micro to Postgres concepts is:
9 | - micro database => Postgres schema
10 | - micro table => Postgres table
11 |
12 | ### Expiry
13 | Expiry is managed by an expiry column in the table. A record's expiry is specified in the column and when a record is read the expiry field is first checked, only returning the record if its still valid otherwise it's deleted. A maintenance loop also periodically runs to delete any rows that have expired.
14 |
--------------------------------------------------------------------------------
/store/postgres/metadata.go:
--------------------------------------------------------------------------------
1 | // Copyright 2020 Asim Aslam
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // https://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 | //
15 | // Original source: github.com/micro/go-plugins/v3/store/cockroach/metadata.go
16 |
17 | package postgres
18 |
19 | import (
20 | "database/sql/driver"
21 | "encoding/json"
22 | "errors"
23 | )
24 |
25 | // https://github.com/upper/db/blob/master/postgresql/custom_types.go#L43
26 | type Metadata map[string]interface{}
27 |
28 | // Scan satisfies the sql.Scanner interface.
29 | func (m *Metadata) Scan(src interface{}) error {
30 | source, ok := src.([]byte)
31 | if !ok {
32 | return errors.New("Type assertion .([]byte) failed.")
33 | }
34 |
35 | var i interface{}
36 | err := json.Unmarshal(source, &i)
37 | if err != nil {
38 | return err
39 | }
40 |
41 | *m, ok = i.(map[string]interface{})
42 | if !ok {
43 | return errors.New("Type assertion .(map[string]interface{}) failed.")
44 | }
45 |
46 | return nil
47 | }
48 |
49 | // Value satisfies the driver.Valuer interface.
50 | func (m Metadata) Value() (driver.Value, error) {
51 | j, err := json.Marshal(m)
52 | return j, err
53 | }
54 |
55 | func toMetadata(m *Metadata) map[string]interface{} {
56 | md := make(map[string]interface{})
57 | for k, v := range *m {
58 | md[k] = v
59 | }
60 | return md
61 | }
62 |
--------------------------------------------------------------------------------
/store/postgres/pgx/README.md:
--------------------------------------------------------------------------------
1 | # Postgres pgx plugin
2 |
3 | This module implements a Postgres implementation of the micro store interface.
4 | It uses modern https://github.com/jackc/pgx driver to access Postgres.
5 |
6 | ## Implementation notes
7 |
8 | ### Concepts
9 | Every database has they own connection pool. Due to the way connections are handled this means that all micro "databases" and "tables" can be stored under a single or several Postgres database as specified in the connection string (https://www.postgresql.org/docs/8.1/ddl-schemas.html). The mapping of micro to Postgres concepts is:
10 | - micro database => Postgres schema
11 | - micro table => Postgres table
12 |
13 | ### Expiry
14 | Expiry is managed by an expiry column in the table. A record's expiry is specified in the column and when a record is read the expiry field is first checked, only returning the record if it's still valid otherwise it's deleted. A maintenance loop also periodically runs to delete any rows that have expired.
15 |
--------------------------------------------------------------------------------
/store/postgres/pgx/db.go:
--------------------------------------------------------------------------------
1 | package pgx
2 |
3 | import "github.com/jackc/pgx/v4/pgxpool"
4 |
5 | type DB struct {
6 | conn *pgxpool.Pool
7 | tables map[string]Queries
8 | }
9 |
--------------------------------------------------------------------------------
/store/postgres/pgx/metadata.go:
--------------------------------------------------------------------------------
1 | package pgx
2 |
3 | import (
4 | "database/sql/driver"
5 | "encoding/json"
6 | "errors"
7 | )
8 |
9 | type Metadata map[string]interface{}
10 |
11 | // Scan satisfies the sql.Scanner interface.
12 | func (m *Metadata) Scan(src interface{}) error {
13 | source, ok := src.([]byte)
14 | if !ok {
15 | return errors.New("type assertion .([]byte) failed")
16 | }
17 |
18 | var i interface{}
19 | err := json.Unmarshal(source, &i)
20 | if err != nil {
21 | return err
22 | }
23 |
24 | *m, ok = i.(map[string]interface{})
25 | if !ok {
26 | return errors.New("type assertion .(map[string]interface{}) failed")
27 | }
28 |
29 | return nil
30 | }
31 |
32 | // Value satisfies the driver.Valuer interface.
33 | func (m *Metadata) Value() (driver.Value, error) {
34 | j, err := json.Marshal(m)
35 | return j, err
36 | }
37 |
38 | func toMetadata(m *Metadata) map[string]interface{} {
39 | md := make(map[string]interface{})
40 | for k, v := range *m {
41 | md[k] = v
42 | }
43 | return md
44 | }
45 |
--------------------------------------------------------------------------------
/store/postgres/pgx/queries.go:
--------------------------------------------------------------------------------
1 | package pgx
2 |
3 | import "fmt"
4 |
5 | type Queries struct {
6 | // read
7 | ListAsc string
8 | ListAscLimit string
9 | ListDesc string
10 | ListDescLimit string
11 | ReadOne string
12 | ReadManyAsc string
13 | ReadManyAscLimit string
14 | ReadManyDesc string
15 | ReadManyDescLimit string
16 |
17 | // change
18 | Write string
19 | Delete string
20 | DeleteExpired string
21 | }
22 |
23 | func NewQueries(database, table string) Queries {
24 | return Queries{
25 | ListAsc: fmt.Sprintf(list, database, table) + asc,
26 | ListAscLimit: fmt.Sprintf(list, database, table) + asc + limit,
27 | ListDesc: fmt.Sprintf(list, database, table) + desc,
28 | ListDescLimit: fmt.Sprintf(list, database, table) + desc + limit,
29 | ReadOne: fmt.Sprintf(readOne, database, table),
30 | ReadManyAsc: fmt.Sprintf(readMany, database, table) + asc,
31 | ReadManyAscLimit: fmt.Sprintf(readMany, database, table) + asc + limit,
32 | ReadManyDesc: fmt.Sprintf(readMany, database, table) + desc,
33 | ReadManyDescLimit: fmt.Sprintf(readMany, database, table) + desc + limit,
34 | Write: fmt.Sprintf(write, database, table),
35 | Delete: fmt.Sprintf(deleteRecord, database, table),
36 | DeleteExpired: fmt.Sprintf(deleteExpired, database, table),
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/store/postgres/pgx/templates.go:
--------------------------------------------------------------------------------
1 | package pgx
2 |
3 | // init
4 |
5 | const createSchema = "CREATE SCHEMA IF NOT EXISTS %s"
6 | const createTable = `CREATE TABLE IF NOT EXISTS %s.%s
7 | (
8 | key text primary key,
9 | value bytea,
10 | metadata JSONB,
11 | expiry timestamp with time zone
12 | )`
13 | const createMDIndex = `create index if not exists idx_md_%s ON %s.%s USING GIN (metadata)`
14 | const createExpiryIndex = `create index if not exists idx_expiry_%s on %s.%s (expiry) where (expiry IS NOT NULL)`
15 |
16 | // base queries
17 | const (
18 | list = "SELECT key FROM %s.%s WHERE key LIKE $1 and (expiry < now() or expiry isnull)"
19 | readOne = "SELECT key, value, metadata, expiry FROM %s.%s WHERE key = $1 and (expiry < now() or expiry isnull)"
20 | readMany = "SELECT key, value, metadata, expiry FROM %s.%s WHERE key LIKE $1 and (expiry < now() or expiry isnull)"
21 | write = `INSERT INTO %s.%s(key, value, metadata, expiry)
22 | VALUES ($1, $2::bytea, $3, $4)
23 | ON CONFLICT (key)
24 | DO UPDATE
25 | SET value = EXCLUDED.value, metadata = EXCLUDED.metadata, expiry = EXCLUDED.expiry`
26 | deleteRecord = "DELETE FROM %s.%s WHERE key = $1"
27 | deleteExpired = "DELETE FROM %s.%s WHERE expiry < now()"
28 | )
29 |
30 | // suffixes
31 | const (
32 | limit = " LIMIT $2 OFFSET $3"
33 | asc = " ORDER BY key ASC"
34 | desc = " ORDER BY key DESC"
35 | )
36 |
--------------------------------------------------------------------------------
/test/benchmark.go:
--------------------------------------------------------------------------------
1 | package test
2 |
3 | import (
4 | "testing"
5 |
6 | "go-micro.dev/v5"
7 | "go-micro.dev/v5/broker"
8 | "go-micro.dev/v5/client"
9 | "go-micro.dev/v5/registry"
10 | "go-micro.dev/v5/server"
11 | "go-micro.dev/v5/transport"
12 | "go-micro.dev/v5/util/test"
13 | )
14 |
15 | func BenchmarkService(b *testing.B) {
16 | cfg := ServiceTestConfig{
17 | Name: "test-service",
18 | NewService: newService,
19 | Parallel: []int{1, 8, 16, 32, 64},
20 | Sequential: []int{0},
21 | Streams: []int{0},
22 | // PubSub: []int{10},
23 | }
24 |
25 | cfg.Run(b)
26 | }
27 |
28 | func newService(name string, opts ...micro.Option) (micro.Service, error) {
29 | r := registry.NewMemoryRegistry(
30 | registry.Services(test.Data),
31 | )
32 |
33 | b := broker.NewMemoryBroker()
34 |
35 | t := transport.NewHTTPTransport()
36 | c := client.NewClient(
37 | client.Transport(t),
38 | client.Broker(b),
39 | )
40 |
41 | s := server.NewRPCServer(
42 | server.Name(name),
43 | server.Registry(r),
44 | server.Transport(t),
45 | server.Broker(b),
46 | )
47 |
48 | if err := s.Init(); err != nil {
49 | return nil, err
50 | }
51 |
52 | options := []micro.Option{
53 | micro.Name(name),
54 | micro.Server(s),
55 | micro.Client(c),
56 | micro.Registry(r),
57 | micro.Broker(b),
58 | }
59 | options = append(options, opts...)
60 |
61 | srv := micro.NewService(options...)
62 |
63 | return srv, nil
64 | }
65 |
--------------------------------------------------------------------------------
/transport/context.go:
--------------------------------------------------------------------------------
1 | package transport
2 |
3 | import (
4 | "net"
5 | )
6 |
7 | type netListener struct{}
8 |
9 | // getNetListener Get net.Listener from ListenOptions.
10 | func getNetListener(o *ListenOptions) net.Listener {
11 | if o.Context == nil {
12 | return nil
13 | }
14 |
15 | if l, ok := o.Context.Value(netListener{}).(net.Listener); ok && l != nil {
16 | return l
17 | }
18 |
19 | return nil
20 | }
21 |
--------------------------------------------------------------------------------
/transport/grpc/handler.go:
--------------------------------------------------------------------------------
1 | package grpc
2 |
3 | import (
4 | "runtime/debug"
5 |
6 | "go-micro.dev/v5/errors"
7 | "go-micro.dev/v5/logger"
8 | "go-micro.dev/v5/transport"
9 | pb "go-micro.dev/v5/transport/grpc/proto"
10 | "google.golang.org/grpc/peer"
11 | )
12 |
13 | // microTransport satisfies the pb.TransportServer inteface.
14 | type microTransport struct {
15 | addr string
16 | fn func(transport.Socket)
17 | }
18 |
19 | func (m *microTransport) Stream(ts pb.Transport_StreamServer) (err error) {
20 | sock := &grpcTransportSocket{
21 | stream: ts,
22 | local: m.addr,
23 | }
24 |
25 | p, ok := peer.FromContext(ts.Context())
26 | if ok {
27 | sock.remote = p.Addr.String()
28 | }
29 |
30 | defer func() {
31 | if r := recover(); r != nil {
32 | logger.Error(r, string(debug.Stack()))
33 | sock.Close()
34 | err = errors.InternalServerError("go.micro.transport", "panic recovered: %v", r)
35 | }
36 | }()
37 |
38 | // execute socket func
39 | m.fn(sock)
40 |
41 | return err
42 | }
43 |
--------------------------------------------------------------------------------
/transport/grpc/proto/transport.proto:
--------------------------------------------------------------------------------
1 | syntax = "proto3";
2 |
3 | option go_package = "./proto;transport";
4 |
5 | package go.micro.transport.grpc;
6 |
7 | service Transport {
8 | rpc Stream(stream Message) returns (stream Message) {}
9 | }
10 |
11 | message Message {
12 | map
22 | Go Micro
23 |
24 |
29 | 
32 |