README

mMicro

Expand ▾ Collapse ▴

Documentation

Overview

    Package micro is a pluggable framework for microservices

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var (
    	HeaderPrefix = "Micro-"
    )

    Functions

    func NewContext

    func NewContext(ctx context.Context, s Service) context.Context

      NewContext returns a new Context with the Service embedded within it.

      func RegisterHandler

      func RegisterHandler(s server.Server, h interface{}, opts ...server.HandlerOption) error

        RegisterHandler is syntactic sugar for registering a handler

        func RegisterSubscriber

        func RegisterSubscriber(topic string, s server.Server, h interface{}, opts ...server.SubscriberOption) error

          RegisterSubscriber is syntactic sugar for registering a subscriber

          Types

          type Event

          type Event interface {
          	// Publish publishes a message to the event topic
          	Publish(ctx context.Context, msg interface{}, opts ...client.PublishOption) error
          }

            Event is used to publish messages to a topic

            func NewEvent

            func NewEvent(topic string, c client.Client) Event

              NewEvent creates a new event publisher

              type Option

              type Option func(*Options)

              func Address

              func Address(addr string) Option

                Address sets the address of the server

                func AfterStart

                func AfterStart(fn func() error) Option

                  AfterStart run funcs after service starts

                  func AfterStop

                  func AfterStop(fn func() error) Option

                    AfterStop run funcs after service stops

                    func BeforeStart

                    func BeforeStart(fn func() error) Option

                      BeforeStart run funcs before service starts

                      func BeforeStop

                      func BeforeStop(fn func() error) Option

                        BeforeStop run funcs before service stops

                        func Broker

                        func Broker(b broker.Broker) Option

                          Broker to be used for service

                          func Context

                          func Context(ctx context.Context) Option

                            Context specifies a context for the service. Can be used to signal shutdown of the service and for extra option values.

                            func HandleSignal

                            func HandleSignal(b bool) Option

                              HandleSignal toggles automatic installation of the signal handler that traps TERM, INT, and QUIT. Users of this feature to disable the signal handler, should control liveness of the service through the context.

                              func Metadata

                              func Metadata(md map[string]string) Option

                                Metadata associated with the service

                                func Name

                                func Name(n string) Option

                                  Name of the service

                                  func Profile

                                  func Profile(p profile.Profile) Option

                                    Profile to be used for debug profile

                                    func RegisterInterval

                                    func RegisterInterval(t time.Duration) Option

                                      RegisterInterval specifies the interval on which to re-register

                                      func RegisterTTL

                                      func RegisterTTL(t time.Duration) Option

                                        RegisterTTL specifies the TTL to use when registering the service

                                        func Registry

                                        func Registry(r registry.Registry) Option

                                          Registry sets the registry for the service and the underlying components

                                          func Selector

                                          func Selector(s selector.Selector) Option

                                            Selector sets the selector for the service client

                                            func Tracer

                                            func Tracer(t trace.Tracer) Option

                                              Tracer sets the tracer for the service

                                              func Transport

                                              func Transport(t transport.Transport) Option

                                                Transport sets the transport for the service and the underlying components

                                                func Version

                                                func Version(v string) Option

                                                  Version of the service

                                                  func WrapCall

                                                  func WrapCall(w ...client.CallWrapper) Option

                                                    WrapCall is a convenience method for wrapping a Client CallFunc

                                                    func WrapClient

                                                    func WrapClient(w ...client.Wrapper) Option

                                                      WrapClient is a convenience method for wrapping a Client with some middleware component. A list of wrappers can be provided. Wrappers are applied in reverse order so the last is executed first.

                                                      func WrapHandler

                                                      func WrapHandler(w ...server.HandlerWrapper) Option

                                                        WrapHandler adds a handler Wrapper to a list of options passed into the server

                                                        func WrapSubscriber

                                                        func WrapSubscriber(w ...server.SubscriberWrapper) Option

                                                          WrapSubscriber adds a subscriber Wrapper to a list of options passed into the server

                                                          type Options

                                                          type Options struct {
                                                          	Broker    broker.Broker
                                                          	Client    client.Client
                                                          	Server    server.Server
                                                          	Registry  registry.Registry
                                                          	Transport transport.Transport
                                                          	Profile   profile.Profile
                                                          
                                                          	// Before and After funcs
                                                          	BeforeStart []func() error
                                                          	BeforeStop  []func() error
                                                          	AfterStart  []func() error
                                                          	AfterStop   []func() error
                                                          
                                                          	// Other options for implementations of the interface
                                                          	// can be stored in a context
                                                          	Context context.Context
                                                          
                                                          	Signal bool
                                                          }

                                                            Options for micro service

                                                            type Service

                                                            type Service interface {
                                                            	// The service name
                                                            	Name() string
                                                            	// Init initialises options
                                                            	Init(...Option)
                                                            	// Options returns the current options
                                                            	Options() Options
                                                            	// Client is used to call services
                                                            	Client() client.Client
                                                            	// Server is for handling requests and events
                                                            	Server() server.Server
                                                            	// Run the service
                                                            	Run() error
                                                            	// The service implementation
                                                            	String() string
                                                            }

                                                              Service is an interface that wraps the lower level libraries within go-micro. Its a convenience method for building and initialising services.

                                                              func FromContext

                                                              func FromContext(ctx context.Context) (Service, bool)

                                                                FromContext retrieves a Service from the Context.

                                                                func NewService

                                                                func NewService(opts ...Option) Service

                                                                  NewService creates and returns a new Service based on the packages within.

                                                                  Directories

                                                                  Path Synopsis
                                                                  api
                                                                  handler
                                                                  Package handler provides http handlers
                                                                  Package handler provides http handlers
                                                                  handler/api
                                                                  Package api provides an http-rpc handler which provides the entire http request over rpc
                                                                  Package api provides an http-rpc handler which provides the entire http request over rpc
                                                                  handler/event
                                                                  Package event provides a handler which publishes an event
                                                                  Package event provides a handler which publishes an event
                                                                  handler/http
                                                                  Package http is a http reverse proxy handler
                                                                  Package http is a http reverse proxy handler
                                                                  handler/rpc
                                                                  Package rpc is a go-micro rpc handler.
                                                                  Package rpc is a go-micro rpc handler.
                                                                  handler/web
                                                                  Package web contains the web handler including websocket support
                                                                  Package web contains the web handler including websocket support
                                                                  resolver
                                                                  Package resolver resolves a http request to an endpoint
                                                                  Package resolver resolves a http request to an endpoint
                                                                  resolver/grpc
                                                                  Package grpc resolves a grpc service like /greeter.Say/Hello to greeter service
                                                                  Package grpc resolves a grpc service like /greeter.Say/Hello to greeter service
                                                                  resolver/host
                                                                  Package host resolves using http host
                                                                  Package host resolves using http host
                                                                  resolver/path
                                                                  Package path resolves using http path
                                                                  Package path resolves using http path
                                                                  resolver/vpath
                                                                  Package vpath resolves using http path and recognised versioned urls
                                                                  Package vpath resolves using http path and recognised versioned urls
                                                                  router
                                                                  Package router provides api service routing
                                                                  Package router provides api service routing
                                                                  router/registry
                                                                  Package registry provides a dynamic api service router
                                                                  Package registry provides a dynamic api service router
                                                                  server
                                                                  Package server provides an API gateway server which handles inbound requests
                                                                  Package server provides an API gateway server which handles inbound requests
                                                                  server/http
                                                                  Package http provides a http server with features; acme, cors, etc
                                                                  Package http provides a http server with features; acme, cors, etc
                                                                  Package broker is an interface used for asynchronous messaging
                                                                  Package broker is an interface used for asynchronous messaging
                                                                  http
                                                                  Package http provides a http based message broker
                                                                  Package http provides a http based message broker
                                                                  memory
                                                                  Package memory provides a memory broker
                                                                  Package memory provides a memory broker
                                                                  nats
                                                                  Package nats provides a NATS broker
                                                                  Package nats provides a NATS broker
                                                                  service
                                                                  Package service provides the broker service client
                                                                  Package service provides the broker service client
                                                                  Package client is an interface for an RPC client
                                                                  Package client is an interface for an RPC client
                                                                  selector
                                                                  Package selector is a way to pick a list of service nodes
                                                                  Package selector is a way to pick a list of service nodes
                                                                  selector/dns
                                                                  Package dns provides a dns SRV selector
                                                                  Package dns provides a dns SRV selector
                                                                  selector/registry
                                                                  Package registry uses the go-micro registry for selection
                                                                  Package registry uses the go-micro registry for selection
                                                                  selector/router
                                                                  Package router is a network/router selector
                                                                  Package router is a network/router selector
                                                                  selector/static
                                                                  Package static provides a static resolver which returns the name/ip passed in without any change
                                                                  Package static provides a static resolver which returns the name/ip passed in without any change
                                                                  Package codec is an interface for encoding messages
                                                                  Package codec is an interface for encoding messages
                                                                  bytes
                                                                  Package bytes provides a bytes codec which does not encode or decode anything
                                                                  Package bytes provides a bytes codec which does not encode or decode anything
                                                                  grpc
                                                                  Package grpc provides a grpc codec
                                                                  Package grpc provides a grpc codec
                                                                  json
                                                                  Package json provides a json codec
                                                                  Package json provides a json codec
                                                                  jsonrpc
                                                                  Package jsonrpc provides a json-rpc 1.0 codec
                                                                  Package jsonrpc provides a json-rpc 1.0 codec
                                                                  proto
                                                                  Package proto provides a proto codec
                                                                  Package proto provides a proto codec
                                                                  protorpc
                                                                  Protorpc provides a net/rpc proto-rpc codec.
                                                                  Protorpc provides a net/rpc proto-rpc codec.
                                                                  text
                                                                  Package text reads any text/* content-type
                                                                  Package text reads any text/* content-type
                                                                  Package config is an interface for dynamic configuration.
                                                                  Package config is an interface for dynamic configuration.
                                                                  encoder
                                                                  Package encoder handles source encoding formats
                                                                  Package encoder handles source encoding formats
                                                                  loader
                                                                  package loader manages loading from multiple sources
                                                                  package loader manages loading from multiple sources
                                                                  reader
                                                                  Package reader parses change sets and provides config values
                                                                  Package reader parses change sets and provides config values
                                                                  secrets
                                                                  Package secrets is an interface for encrypting and decrypting secrets
                                                                  Package secrets is an interface for encrypting and decrypting secrets
                                                                  secrets/box
                                                                  Package box is an asymmetric implementation of config/secrets using nacl/box
                                                                  Package box is an asymmetric implementation of config/secrets using nacl/box
                                                                  secrets/secretbox
                                                                  Package secretbox is a config/secrets implementation that uses nacl/secretbox to do symmetric encryption / verification
                                                                  Package secretbox is a config/secrets implementation that uses nacl/secretbox to do symmetric encryption / verification
                                                                  source
                                                                  Package source is the interface for sources
                                                                  Package source is the interface for sources
                                                                  source/file
                                                                  Package file is a file source.
                                                                  Package file is a file source.
                                                                  source/memory
                                                                  Package memory is a memory source
                                                                  Package memory is a memory source
                                                                  Package debug provides micro debug packages
                                                                  Package debug provides micro debug packages
                                                                  log
                                                                  Package log provides debug logging
                                                                  Package log provides debug logging
                                                                  log/kubernetes
                                                                  Package kubernetes is a logger implementing (github.com/Allenxuxu/mMicro/debug/log).Log
                                                                  Package kubernetes is a logger implementing (github.com/Allenxuxu/mMicro/debug/log).Log
                                                                  log/memory
                                                                  Package memory provides an in memory log buffer
                                                                  Package memory provides an in memory log buffer
                                                                  profile
                                                                  Package profile is for profilers
                                                                  Package profile is for profilers
                                                                  profile/http
                                                                  Package http enables the http profiler
                                                                  Package http enables the http profiler
                                                                  profile/pprof
                                                                  Package pprof provides a pprof profiler
                                                                  Package pprof provides a pprof profiler
                                                                  service
                                                                  Package service provides the service log
                                                                  Package service provides the service log
                                                                  service/handler
                                                                  Package handler implements service debug handler embedded in go-micro services
                                                                  Package handler implements service debug handler embedded in go-micro services
                                                                  stats
                                                                  Package stats provides runtime stats
                                                                  Package stats provides runtime stats
                                                                  trace
                                                                  Package trace provides an interface for distributed tracing
                                                                  Package trace provides an interface for distributed tracing
                                                                  Package errors provides a way to return detailed information for an RPC request error.
                                                                  Package errors provides a way to return detailed information for an RPC request error.
                                                                  example
                                                                  srv
                                                                  web
                                                                  Package log provides a log interface
                                                                  Package log provides a log interface
                                                                  Package metadata is a way of defining message headers
                                                                  Package metadata is a way of defining message headers
                                                                  Package registry is an interface for service discovery
                                                                  Package registry is an interface for service discovery
                                                                  cache
                                                                  Package cache provides a registry cache
                                                                  Package cache provides a registry cache
                                                                  etcd
                                                                  Package etcd provides an etcd service registry
                                                                  Package etcd provides an etcd service registry
                                                                  mdns
                                                                  Package mdns provides a multicast dns registry
                                                                  Package mdns provides a multicast dns registry
                                                                  memory
                                                                  Package memory provides an in-memory registry
                                                                  Package memory provides an in-memory registry
                                                                  service
                                                                  Package service uses the registry service
                                                                  Package service uses the registry service
                                                                  Package router provides a network routing control plane
                                                                  Package router provides a network routing control plane
                                                                  Package server is an interface for a micro server
                                                                  Package server is an interface for a micro server
                                                                  Package transport is an interface for synchronous connection based communication
                                                                  Package transport is an interface for synchronous connection based communication
                                                                  grpc
                                                                  Package grpc provides a grpc transport
                                                                  Package grpc provides a grpc transport
                                                                  memory
                                                                  Package memory is an in-memory transport
                                                                  Package memory is an in-memory transport
                                                                  quic
                                                                  Package quic provides a QUIC based transport
                                                                  Package quic provides a QUIC based transport
                                                                  util
                                                                  backoff
                                                                  Package backoff provides backoff functionality
                                                                  Package backoff provides backoff functionality
                                                                  buf
                                                                  ctx
                                                                  io
                                                                  Package io is for io management
                                                                  Package io is for io management
                                                                  jitter
                                                                  Package jitter provides a random jitter
                                                                  Package jitter provides a random jitter
                                                                  kubernetes/client
                                                                  Package client provides an implementation of a restricted subset of kubernetes API client
                                                                  Package client provides an implementation of a restricted subset of kubernetes API client
                                                                  log
                                                                  Package log is a global internal logger DEPRECATED: this is frozen package, use github.com/Allenxuxu/mMicro/logger
                                                                  Package log is a global internal logger DEPRECATED: this is frozen package, use github.com/Allenxuxu/mMicro/logger
                                                                  net
                                                                  pool
                                                                  Package pool is a connection pool
                                                                  Package pool is a connection pool
                                                                  proto
                                                                  Package proto contains utility functions for working with protobufs
                                                                  Package proto contains utility functions for working with protobufs
                                                                  ring
                                                                  Package ring provides a simple ring buffer for storing local data
                                                                  Package ring provides a simple ring buffer for storing local data
                                                                  socket
                                                                  Package socket provides a pseudo socket
                                                                  Package socket provides a pseudo socket
                                                                  stream
                                                                  Package stream encapsulates streams within streams
                                                                  Package stream encapsulates streams within streams
                                                                  tls
                                                                  Package web provides web based micro services
                                                                  Package web provides web based micro services