go/go-micro
1
0
Fork 0
mirror of https://github.com/go-micro/go-micro.git synced 2025-06-30 22:33:49 +02:00
Code Issues Releases Activity

Plugins and profiles (#2764)

Browse Source 
* feat: more plugins

* chore(ci): split out benchmarks

Attempt to resolve too many open files in ci

* chore(ci): split out benchmarks

* fix(ci): Attempt to resolve too many open files in ci

* fix: set DefaultX for cli flag and service option

* fix: restore http broker

* fix: default http broker

* feat: full nats profile

* chore: still ugly, not ready

* fix: better initialization for profiles

* fix(tests): comment out flaky listen tests

* fix: disable benchmarks on gha

* chore: cleanup, comments

* chore: add nats config source
This commit is contained in:
Brian Ketelsen
2025-05-20 13:24:06 -04:00
committed by GitHub
parent e12504ce3a
commit ddc34801ee
58 changed files with 6792 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/tests.yaml vendored
View File

@ -27,7 +27,7 @@ jobs:
go get -v -t -d ./...
- name: Run tests
id: tests
run: richgo test -v -race -cover -bench=. ./...
run: richgo test -v -race -cover ./...
env:
IN_TRAVIS_CI: yes
RICHGO_FORCE_COLOR: 1

157
auth/jwt/jwt.go Normal file
View File

@ -0,0 +1,157 @@
package jwt
import (
"sync"
"time"
jwtToken "github.com/micro/plugins/v5/auth/jwt/token"
"go-micro.dev/v5/auth"
"go-micro.dev/v5/cmd"
)
func init() {
cmd.DefaultAuths["jwt"] = NewAuth
}
// NewAuth returns a new instance of the Auth service.
func NewAuth(opts ...auth.Option) auth.Auth {
j := new(jwt)
j.Init(opts...)
return j
}
func NewRules() auth.Rules {
return new(jwtRules)
}
type jwt struct {
sync.Mutex
options auth.Options
jwt jwtToken.Provider
}
type jwtRules struct {
sync.Mutex
rules []*auth.Rule
}
func (j *jwt) String() string {
return "jwt"
}
func (j *jwt) Init(opts ...auth.Option) {
j.Lock()
defer j.Unlock()
for _, o := range opts {
o(&j.options)
}
j.jwt = jwtToken.New(
jwtToken.WithPrivateKey(j.options.PrivateKey),
jwtToken.WithPublicKey(j.options.PublicKey),
)
}
func (j *jwt) Options() auth.Options {
j.Lock()
defer j.Unlock()
return j.options
}
func (j *jwt) Generate(id string, opts ...auth.GenerateOption) (*auth.Account, error) {
options := auth.NewGenerateOptions(opts...)
account := &auth.Account{
ID: id,
Type: options.Type,
Scopes: options.Scopes,
Metadata: options.Metadata,
Issuer: j.Options().Namespace,
}
// generate a JWT secret which can be provided to the Token() method
// and exchanged for an access token
secret, err := j.jwt.Generate(account)
if err != nil {
return nil, err
}
account.Secret = secret.Token
// return the account
return account, nil
}
func (j *jwtRules) Grant(rule *auth.Rule) error {
j.Lock()
defer j.Unlock()
j.rules = append(j.rules, rule)
return nil
}
func (j *jwtRules) Revoke(rule *auth.Rule) error {
j.Lock()
defer j.Unlock()
rules := make([]*auth.Rule, 0, len(j.rules))
for _, r := range j.rules {
if r.ID != rule.ID {
rules = append(rules, r)
}
}
j.rules = rules
return nil
}
func (j *jwtRules) Verify(acc *auth.Account, res *auth.Resource, opts ...auth.VerifyOption) error {
j.Lock()
defer j.Unlock()
var options auth.VerifyOptions
for _, o := range opts {
o(&options)
}
return auth.Verify(j.rules, acc, res)
}
func (j *jwtRules) List(opts ...auth.ListOption) ([]*auth.Rule, error) {
j.Lock()
defer j.Unlock()
return j.rules, nil
}
func (j *jwt) Inspect(token string) (*auth.Account, error) {
return j.jwt.Inspect(token)
}
func (j *jwt) Token(opts ...auth.TokenOption) (*auth.Token, error) {
options := auth.NewTokenOptions(opts...)
secret := options.RefreshToken
if len(options.Secret) > 0 {
secret = options.Secret
}
account, err := j.jwt.Inspect(secret)
if err != nil {
return nil, err
}
access, err := j.jwt.Generate(account, jwtToken.WithExpiry(options.Expiry))
if err != nil {
return nil, err
}
refresh, err := j.jwt.Generate(account, jwtToken.WithExpiry(options.Expiry+time.Hour))
if err != nil {
return nil, err
}
return &auth.Token{
Created: access.Created,
Expiry: access.Expiry,
AccessToken: access.Token,
RefreshToken: refresh.Token,
}, nil
}

109
auth/jwt/token/jwt.go Normal file
View File

@ -0,0 +1,109 @@
package token
import (
"encoding/base64"
"time"
"github.com/dgrijalva/jwt-go"
"go-micro.dev/v5/auth"
)
// authClaims to be encoded in the JWT.
type authClaims struct {
Type string `json:"type"`
Scopes []string `json:"scopes"`
Metadata map[string]string `json:"metadata"`
jwt.StandardClaims
}
// JWT implementation of token provider.
type JWT struct {
opts Options
}
// New returns an initialized basic provider.
func New(opts ...Option) Provider {
return &JWT{
opts: NewOptions(opts...),
}
}
// Generate a new JWT.
func (j *JWT) Generate(acc *auth.Account, opts ...GenerateOption) (*Token, error) {
// decode the private key
priv, err := base64.StdEncoding.DecodeString(j.opts.PrivateKey)
if err != nil {
return nil, err
}
// parse the private key
key, err := jwt.ParseRSAPrivateKeyFromPEM(priv)
if err != nil {
return nil, ErrEncodingToken
}
// parse the options
options := NewGenerateOptions(opts...)
// generate the JWT
expiry := time.Now().Add(options.Expiry)
t := jwt.NewWithClaims(jwt.SigningMethodRS256, authClaims{
acc.Type, acc.Scopes, acc.Metadata, jwt.StandardClaims{
Subject: acc.ID,
Issuer: acc.Issuer,
ExpiresAt: expiry.Unix(),
},
})
tok, err := t.SignedString(key)
if err != nil {
return nil, err
}
// return the token
return &Token{
Token: tok,
Expiry: expiry,
Created: time.Now(),
}, nil
}
// Inspect a JWT.
func (j *JWT) Inspect(t string) (*auth.Account, error) {
// decode the public key
pub, err := base64.StdEncoding.DecodeString(j.opts.PublicKey)
if err != nil {
return nil, err
}
// parse the public key
res, err := jwt.ParseWithClaims(t, &authClaims{}, func(token *jwt.Token) (interface{}, error) {
return jwt.ParseRSAPublicKeyFromPEM(pub)
})
if err != nil {
return nil, ErrInvalidToken
}
// validate the token
if !res.Valid {
return nil, ErrInvalidToken
}
claims, ok := res.Claims.(*authClaims)
if !ok {
return nil, ErrInvalidToken
}
// return the token
return &auth.Account{
ID: claims.Subject,
Issuer: claims.Issuer,
Type: claims.Type,
Scopes: claims.Scopes,
Metadata: claims.Metadata,
}, nil
}
// String returns JWT.
func (j *JWT) String() string {
return "jwt"
}

85
auth/jwt/token/jwt_test.go Normal file
View File

@ -0,0 +1,85 @@
package token
import (
"os"
"testing"
"time"
"go-micro.dev/v5/auth"
)
func TestGenerate(t *testing.T) {
privKey, err := os.ReadFile("test/sample_key")
if err != nil {
t.Fatalf("Unable to read private key: %v", err)
}
j := New(
WithPrivateKey(string(privKey)),
)
_, err = j.Generate(&auth.Account{ID: "test"})
if err != nil {
t.Fatalf("Generate returned %v error, expected nil", err)
}
}
func TestInspect(t *testing.T) {
pubKey, err := os.ReadFile("test/sample_key.pub")
if err != nil {
t.Fatalf("Unable to read public key: %v", err)
}
privKey, err := os.ReadFile("test/sample_key")
if err != nil {
t.Fatalf("Unable to read private key: %v", err)
}
j := New(
WithPublicKey(string(pubKey)),
WithPrivateKey(string(privKey)),
)
t.Run("Valid token", func(t *testing.T) {
md := map[string]string{"foo": "bar"}
scopes := []string{"admin"}
subject := "test"
acc := &auth.Account{ID: subject, Scopes: scopes, Metadata: md}
tok, err := j.Generate(acc)
if err != nil {
t.Fatalf("Generate returned %v error, expected nil", err)
}
tok2, err := j.Inspect(tok.Token)
if err != nil {
t.Fatalf("Inspect returned %v error, expected nil", err)
}
if acc.ID != subject {
t.Errorf("Inspect returned %v as the token subject, expected %v", acc.ID, subject)
}
if len(tok2.Scopes) != len(scopes) {
t.Errorf("Inspect returned %v scopes, expected %v", len(tok2.Scopes), len(scopes))
}
if len(tok2.Metadata) != len(md) {
t.Errorf("Inspect returned %v as the token metadata, expected %v", tok2.Metadata, md)
}
})
t.Run("Expired token", func(t *testing.T) {
tok, err := j.Generate(&auth.Account{}, WithExpiry(-10*time.Second))
if err != nil {
t.Fatalf("Generate returned %v error, expected nil", err)
}
if _, err = j.Inspect(tok.Token); err != ErrInvalidToken {
t.Fatalf("Inspect returned %v error, expected %v", err, ErrInvalidToken)
}
})
t.Run("Invalid token", func(t *testing.T) {
_, err := j.Inspect("Invalid token")
if err != ErrInvalidToken {
t.Fatalf("Inspect returned %v error, expected %v", err, ErrInvalidToken)
}
})
}

78
auth/jwt/token/options.go Normal file
View File

@ -0,0 +1,78 @@
package token
import (
"time"
"go-micro.dev/v5/store"
)
type Options struct {
// Store to persist the tokens
Store store.Store
// PublicKey base64 encoded, used by JWT
PublicKey string
// PrivateKey base64 encoded, used by JWT
PrivateKey string
}
type Option func(o *Options)
// WithStore sets the token providers store.
func WithStore(s store.Store) Option {
return func(o *Options) {
o.Store = s
}
}
// WithPublicKey sets the JWT public key.
func WithPublicKey(key string) Option {
return func(o *Options) {
o.PublicKey = key
}
}
// WithPrivateKey sets the JWT private key.
func WithPrivateKey(key string) Option {
return func(o *Options) {
o.PrivateKey = key
}
}
func NewOptions(opts ...Option) Options {
var options Options
for _, o := range opts {
o(&options)
}
// set default store
if options.Store == nil {
options.Store = store.DefaultStore
}
return options
}
type GenerateOptions struct {
// Expiry for the token
Expiry time.Duration
}
type GenerateOption func(o *GenerateOptions)
// WithExpiry for the generated account's token expires.
func WithExpiry(d time.Duration) GenerateOption {
return func(o *GenerateOptions) {
o.Expiry = d
}
}
// NewGenerateOptions from a slice of options.
func NewGenerateOptions(opts ...GenerateOption) GenerateOptions {
var options GenerateOptions
for _, o := range opts {
o(&options)
}
// set default Expiry of token
if options.Expiry == 0 {
options.Expiry = time.Minute * 15
}
return options
}

1
auth/jwt/token/test/sample_key Normal file
View File

@ -0,0 +1 @@
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

1
auth/jwt/token/test/sample_key 2 Normal file
View File

@ -0,0 +1 @@
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

1
auth/jwt/token/test/sample_key.pub Normal file
View File

@ -0,0 +1 @@
LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQ0lqQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FnOEFNSUlDQ2dLQ0FnRUE4U2JKUDVYYkVpZFJtNWIyc05wTApHbzJlV2ZVNU9KZTBpemdySHdEOEg3RjZQa1BkL1JsOS8xcE1WN01pTzNMSHd0aEhDMkJSWXFyKzF3RmRvWkNHCkJZckxhWHVYRnFLMHZ1WmhQcUUzYXpqdUlIUXUwQkgvbFhRTXF5RXFGNU1JMnplakM0ek16cjE1T04rZ0U0Sm4KaXBqcC9DZGpPUEFEbUpHK0JKOXFlRS9RUGVtL21VZElUL0xhRjdrUXh5WUs1VktuK05nT1d6TWx6S0FBcENuNwpUVEtCVWU4RlpHNldTWDdMVjBlTEdIc29pYnhsbzlqRGpsWTVvQk9jemZxZU5XSEs1R1hCN1F3cExOaDk0NlB6ClpucW9hcFdVZStZL1JPaUhpekpUY3I1Wk1TTDV3bEVxOGhOaG1obTVOTmUvTytHZ2pCRE5TZlVoMDYrcTRuZ20KYm1OWDVoODM4QmJqUmN5YzM2ZHd6NkpVK2R1b1J0UWhnaVk5MTBwUGY5YmF1WFdxd1VDVWE0cXNIempLUjBMLwpOMVhYQXlsQ0RqeWVnWnp6Y093MkNIOFNrZkZVcmdMclBiRUI5ZWdjR2szOCticEtzM1o2UnI1K3RuRDFCSVBJCkZHTGVJMFVPQzAreGlCdjBvenhJRE9GbldhOVVUR0R4VXg4b2o4VkllUm5XRHE2TWMxaUpwOFV5Y2lCSVRSdHcKNGRabzcweG1mbmVJV3pyM0tTTmFoU29nSmRSMGxhUXpBdVAzYWlXWElNcDJzYzhTYytCbCtMalhtQm94QnJhQgpIaDlLa0pKRWNnQUZ3czJib2pDbEpPWXhvRi9YZ0ZLU3NJbkhEckhWT3lXUEJlM2ZhZEVjNzdiK25iL2V4T3pyCjFFcnhoR2c5akZtcmtPK3M0eEdodjZNQ0F3RUFBUT09Ci0tLS0tRU5EIFBVQkxJQyBLRVktLS0tLQo=

33
auth/jwt/token/token.go Normal file
View File

@ -0,0 +1,33 @@
package token
import (
"errors"
"time"
"go-micro.dev/v5/auth"
)
var (
// ErrNotFound is returned when a token cannot be found.
ErrNotFound = errors.New("token not found")
// ErrEncodingToken is returned when the service encounters an error during encoding.
ErrEncodingToken = errors.New("error encoding the token")
// ErrInvalidToken is returned when the token provided is not valid.
ErrInvalidToken = errors.New("invalid token provided")
)
// Provider generates and inspects tokens.
type Provider interface {
Generate(account *auth.Account, opts ...GenerateOption) (*Token, error)
Inspect(token string) (*auth.Account, error)
String() string
}
type Token struct {
// The actual token
Token string `json:"token"`
// Time of token creation
Created time.Time `json:"created"`
// Time of token expiry
Expiry time.Time `json:"expiry"`
}

2
broker/broker.go
View File

@ -41,7 +41,7 @@ type Subscriber interface {
var (
// DefaultBroker is the default Broker.
DefaultBroker = NewMemoryBroker()
DefaultBroker = NewHttpBroker()
)
func Init(opts ...Option) error {

38
broker/http/http.go → broker/http.go
View File

@ -1,5 +1,4 @@
// Package http provides a http based message broker
package http
package broker
import (
"bytes"
@ -16,7 +15,6 @@ import (
"time"
"github.com/google/uuid"
"go-micro.dev/v5/broker"
"go-micro.dev/v5/codec/json"
merr "go-micro.dev/v5/errors"
"go-micro.dev/v5/registry"
@ -30,7 +28,7 @@ import (
// HTTP Broker is a point to point async broker.
type httpBroker struct {
opts broker.Options
opts Options
r registry.Registry
@ -52,8 +50,8 @@ type httpBroker struct {
}
type httpSubscriber struct {
opts broker.SubscribeOptions
fn broker.Handler
opts SubscribeOptions
fn Handler
svc *registry.Service
hb *httpBroker
id string
@ -62,7 +60,7 @@ type httpSubscriber struct {
type httpEvent struct {
err error
m *broker.Message
m *Message
t string
}
@ -109,8 +107,8 @@ func newTransport(config *tls.Config) *http.Transport {
return t
}
func newHttpBroker(opts ...broker.Option) broker.Broker {
options := *broker.NewOptions(opts...)
func newHttpBroker(opts ...Option) Broker {
options := *NewOptions(opts...)
options.Registry = registry.DefaultRegistry
options.Codec = json.Marshaler{}
@ -162,7 +160,7 @@ func (h *httpEvent) Error() error {
return h.err
}
func (h *httpEvent) Message() *broker.Message {
func (h *httpEvent) Message() *Message {
return h.m
}
@ -170,7 +168,7 @@ func (h *httpEvent) Topic() string {
return h.t
}
func (h *httpSubscriber) Options() broker.SubscribeOptions {
func (h *httpSubscriber) Options() SubscribeOptions {
return h.opts
}
@ -309,7 +307,7 @@ func (h *httpBroker) ServeHTTP(w http.ResponseWriter, req *http.Request) {
return
}
var m *broker.Message
var m *Message
if err = h.opts.Codec.Unmarshal(b, &m); err != nil {
errr := merr.InternalServerError("go.micro.broker", "Error parsing request body: %v", err)
w.WriteHeader(500)
@ -331,7 +329,7 @@ func (h *httpBroker) ServeHTTP(w http.ResponseWriter, req *http.Request) {
id := req.Form.Get("id")
//nolint:prealloc
var subs []broker.Handler
var subs []Handler
h.RLock()
for _, subscriber := range h.subscribers[topic] {
@ -459,7 +457,7 @@ func (h *httpBroker) Disconnect() error {
return err
}
func (h *httpBroker) Init(opts ...broker.Option) error {
func (h *httpBroker) Init(opts ...Option) error {
h.RLock()
if h.running {
h.RUnlock()
@ -506,13 +504,13 @@ func (h *httpBroker) Init(opts ...broker.Option) error {
return nil
}
func (h *httpBroker) Options() broker.Options {
func (h *httpBroker) Options() Options {
return h.opts
}
func (h *httpBroker) Publish(topic string, msg *broker.Message, opts ...broker.PublishOption) error {
func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption) error {
// create the message first
m := &broker.Message{
m := &Message{
Header: make(map[string]string),
Body: msg.Body,
}
@ -638,10 +636,10 @@ func (h *httpBroker) Publish(topic string, msg *broker.Message, opts ...broker.P
return nil
}
func (h *httpBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
var err error
var host, port string
options := broker.NewSubscribeOptions(opts...)
options := NewSubscribeOptions(opts...)
// parse address for host, port
host, port, err = net.SplitHostPort(h.Address())
@ -707,6 +705,6 @@ func (h *httpBroker) String() string {
}
// NewHttpBroker returns a new http broker.
func NewHttpBroker(opts ...broker.Option) broker.Broker {
func NewHttpBroker(opts ...Option) Broker {
return newHttpBroker(opts...)
}

28
broker/http/http_test.go → broker/http_test.go
View File

@ -1,4 +1,4 @@
package http_test
package broker_test
import (
"sync"
@ -7,7 +7,6 @@ import (
"github.com/google/uuid"
"go-micro.dev/v5/broker"
"go-micro.dev/v5/broker/http"
"go-micro.dev/v5/registry"
)
@ -61,7 +60,7 @@ func sub(b *testing.B, c int) {
b.StopTimer()
m := newTestRegistry()
brker := http.NewHttpBroker(broker.Registry(m))
brker := broker.NewHttpBroker(broker.Registry(m))
topic := uuid.New().String()
if err := brker.Init(); err != nil {
@ -122,7 +121,7 @@ func sub(b *testing.B, c int) {
func pub(b *testing.B, c int) {
b.StopTimer()
m := newTestRegistry()
brk := http.NewHttpBroker(broker.Registry(m))
brk := broker.NewHttpBroker(broker.Registry(m))
topic := uuid.New().String()
if err := brk.Init(); err != nil {
@ -191,7 +190,7 @@ func pub(b *testing.B, c int) {
func TestBroker(t *testing.T) {
m := newTestRegistry()
b := http.NewHttpBroker(broker.Registry(m))
b := broker.NewHttpBroker(broker.Registry(m))
if err := b.Init(); err != nil {
t.Fatalf("Unexpected init error: %v", err)
@ -240,7 +239,7 @@ func TestBroker(t *testing.T) {
func TestConcurrentSubBroker(t *testing.T) {
m := newTestRegistry()
b := http.NewHttpBroker(broker.Registry(m))
b := broker.NewHttpBroker(broker.Registry(m))
if err := b.Init(); err != nil {
t.Fatalf("Unexpected init error: %v", err)
@ -299,7 +298,7 @@ func TestConcurrentSubBroker(t *testing.T) {
func TestConcurrentPubBroker(t *testing.T) {
m := newTestRegistry()
b := http.NewHttpBroker(broker.Registry(m))
b := broker.NewHttpBroker(broker.Registry(m))
if err := b.Init(); err != nil {
t.Fatalf("Unexpected init error: %v", err)
@ -363,13 +362,6 @@ func BenchmarkSub32(b *testing.B) {
sub(b, 32)
}
func BenchmarkSub64(b *testing.B) {
sub(b, 64)
}
func BenchmarkSub128(b *testing.B) {
sub(b, 128)
}
func BenchmarkPub1(b *testing.B) {
pub(b, 1)
@ -382,11 +374,3 @@ func BenchmarkPub8(b *testing.B) {
func BenchmarkPub32(b *testing.B) {
pub(b, 32)
}
func BenchmarkPub64(b *testing.B) {
pub(b, 64)
}
func BenchmarkPub128(b *testing.B) {
pub(b, 128)
}

12
broker/rabbitmq/auth.go Normal file
View File

@ -0,0 +1,12 @@
package rabbitmq
type ExternalAuthentication struct {
}
func (auth *ExternalAuthentication) Mechanism() string {
return "EXTERNAL"
}
func (auth *ExternalAuthentication) Response() string {
return ""
}

178
broker/rabbitmq/channel.go Normal file
View File

@ -0,0 +1,178 @@
package rabbitmq
//
// All credit to Mondo
//
import (
"errors"
"sync"
"github.com/google/uuid"
"github.com/streadway/amqp"
)
type rabbitMQChannel struct {
uuid string
connection *amqp.Connection
channel *amqp.Channel
confirmPublish chan amqp.Confirmation
mtx sync.Mutex
}
func newRabbitChannel(conn *amqp.Connection, prefetchCount int, prefetchGlobal bool, confirmPublish bool) (*rabbitMQChannel, error) {
id, err := uuid.NewRandom()
if err != nil {
return nil, err
}
rabbitCh := &rabbitMQChannel{
uuid: id.String(),
connection: conn,
}
if err := rabbitCh.Connect(prefetchCount, prefetchGlobal, confirmPublish); err != nil {
return nil, err
}
return rabbitCh, nil
}
func (r *rabbitMQChannel) Connect(prefetchCount int, prefetchGlobal bool, confirmPublish bool) error {
var err error
r.channel, err = r.connection.Channel()
if err != nil {
return err
}
err = r.channel.Qos(prefetchCount, 0, prefetchGlobal)
if err != nil {
return err
}
if confirmPublish {
r.confirmPublish = r.channel.NotifyPublish(make(chan amqp.Confirmation, 1))
err = r.channel.Confirm(false)
if err != nil {
return err
}
}
return nil
}
func (r *rabbitMQChannel) Close() error {
if r.channel == nil {
return errors.New("Channel is nil")
}
return r.channel.Close()
}
func (r *rabbitMQChannel) Publish(exchange, key string, message amqp.Publishing) error {
if r.channel == nil {
return errors.New("Channel is nil")
}
if r.confirmPublish != nil {
r.mtx.Lock()
defer r.mtx.Unlock()
}
err := r.channel.Publish(exchange, key, false, false, message)
if err != nil {
return err
}
if r.confirmPublish != nil {
confirmation, ok := <-r.confirmPublish
if !ok {
return errors.New("Channel closed before could receive confirmation of publish")
}
if !confirmation.Ack {
return errors.New("Could not publish message, received nack from broker on confirmation")
}
}
return nil
}
func (r *rabbitMQChannel) DeclareExchange(ex Exchange) error {
return r.channel.ExchangeDeclare(
ex.Name, // name
string(ex.Type), // kind
ex.Durable, // durable
false, // autoDelete
false, // internal
false, // noWait
nil, // args
)
}
func (r *rabbitMQChannel) DeclareDurableExchange(ex Exchange) error {
return r.channel.ExchangeDeclare(
ex.Name, // name
string(ex.Type), // kind
true, // durable
false, // autoDelete
false, // internal
false, // noWait
nil, // args
)
}
func (r *rabbitMQChannel) DeclareQueue(queue string, args amqp.Table) error {
_, err := r.channel.QueueDeclare(
queue, // name
false, // durable
true, // autoDelete
false, // exclusive
false, // noWait
args, // args
)
return err
}
func (r *rabbitMQChannel) DeclareDurableQueue(queue string, args amqp.Table) error {
_, err := r.channel.QueueDeclare(
queue, // name
true, // durable
false, // autoDelete
false, // exclusive
false, // noWait
args, // args
)
return err
}
func (r *rabbitMQChannel) DeclareReplyQueue(queue string) error {
_, err := r.channel.QueueDeclare(
queue, // name
false, // durable
true, // autoDelete
true, // exclusive
false, // noWait
nil, // args
)
return err
}
func (r *rabbitMQChannel) ConsumeQueue(queue string, autoAck bool) (<-chan amqp.Delivery, error) {
return r.channel.Consume(
queue, // queue
r.uuid, // consumer
autoAck, // autoAck
false, // exclusive
false, // nolocal
false, // nowait
nil, // args
)
}
func (r *rabbitMQChannel) BindQueue(queue, key, exchange string, args amqp.Table) error {
return r.channel.QueueBind(
queue, // name
key, // key
exchange, // exchange
false, // noWait
args, // args
)
}

300
broker/rabbitmq/connection.go Normal file
View File

@ -0,0 +1,300 @@
package rabbitmq
//
// All credit to Mondo
//
import (
"crypto/tls"
"regexp"
"strings"
"sync"
"time"
"github.com/streadway/amqp"
"go-micro.dev/v5/logger"
)
type MQExchangeType string
const (
ExchangeTypeFanout MQExchangeType = "fanout"
ExchangeTypeTopic = "topic"
ExchangeTypeDirect = "direct"
)
var (
DefaultExchange = Exchange{
Name: "micro",
Type: ExchangeTypeTopic,
}
DefaultRabbitURL = "amqp://guest:guest@127.0.0.1:5672"
DefaultPrefetchCount = 0
DefaultPrefetchGlobal = false
DefaultRequeueOnError = false
DefaultConfirmPublish = false
DefaultWithoutExchange = false
// The amqp library does not seem to set these when using amqp.DialConfig
// (even though it says so in the comments) so we set them manually to make
// sure to not brake any existing functionality.
defaultHeartbeat = 10 * time.Second
defaultLocale = "en_US"
defaultAmqpConfig = amqp.Config{
Heartbeat: defaultHeartbeat,
Locale: defaultLocale,
}
dial = amqp.Dial
dialTLS = amqp.DialTLS
dialConfig = amqp.DialConfig
)
type rabbitMQConn struct {
Connection *amqp.Connection
Channel *rabbitMQChannel
ExchangeChannel *rabbitMQChannel
exchange Exchange
withoutExchange bool
url string
prefetchCount int
prefetchGlobal bool
confirmPublish bool
sync.Mutex
connected bool
close chan bool
waitConnection chan struct{}
logger logger.Logger
}
// Exchange is the rabbitmq exchange.
type Exchange struct {
// Name of the exchange
Name string
// Type of the exchange
Type MQExchangeType
// Whether its persistent
Durable bool
}
func newRabbitMQConn(ex Exchange, urls []string, prefetchCount int, prefetchGlobal bool, confirmPublish bool, withoutExchange bool, logger logger.Logger) *rabbitMQConn {
var url string
if len(urls) > 0 && regexp.MustCompile("^amqp(s)?://.*").MatchString(urls[0]) {
url = urls[0]
} else {
url = DefaultRabbitURL
}
ret := &rabbitMQConn{
exchange: ex,
url: url,
withoutExchange: withoutExchange,
prefetchCount: prefetchCount,
prefetchGlobal: prefetchGlobal,
confirmPublish: confirmPublish,
close: make(chan bool),
waitConnection: make(chan struct{}),
logger: logger,
}
// its bad case of nil == waitConnection, so close it at start
close(ret.waitConnection)
return ret
}
func (r *rabbitMQConn) connect(secure bool, config *amqp.Config) error {
// try connect
if err := r.tryConnect(secure, config); err != nil {
return err
}
// connected
r.Lock()
r.connected = true
r.Unlock()
// create reconnect loop
go r.reconnect(secure, config)
return nil
}
func (r *rabbitMQConn) reconnect(secure bool, config *amqp.Config) {
// skip first connect
var connect bool
for {
if connect {
// try reconnect
if err := r.tryConnect(secure, config); err != nil {
time.Sleep(1 * time.Second)
continue
}
// connected
r.Lock()
r.connected = true
r.Unlock()
// unblock resubscribe cycle - close channel
//at this point channel is created and unclosed - close it without any additional checks
close(r.waitConnection)
}
connect = true
notifyClose := make(chan *amqp.Error)
r.Connection.NotifyClose(notifyClose)
chanNotifyClose := make(chan *amqp.Error)
var channel *amqp.Channel
if !r.withoutExchange {
channel = r.ExchangeChannel.channel
} else {
channel = r.Channel.channel
}
channel.NotifyClose(chanNotifyClose)
// To avoid deadlocks it is necessary to consume the messages from all channels.
for notifyClose != nil || chanNotifyClose != nil {
// block until closed
select {
case err := <-chanNotifyClose:
r.logger.Log(logger.ErrorLevel, err)
// block all resubscribe attempt - they are useless because there is no connection to rabbitmq
// create channel 'waitConnection' (at this point channel is nil or closed, create it without unnecessary checks)
r.Lock()
r.connected = false
r.waitConnection = make(chan struct{})
r.Unlock()
chanNotifyClose = nil
case err := <-notifyClose:
r.logger.Log(logger.ErrorLevel, err)
// block all resubscribe attempt - they are useless because there is no connection to rabbitmq
// create channel 'waitConnection' (at this point channel is nil or closed, create it without unnecessary checks)
r.Lock()
r.connected = false
r.waitConnection = make(chan struct{})
r.Unlock()
notifyClose = nil
case <-r.close:
return
}
}
}
}
func (r *rabbitMQConn) Connect(secure bool, config *amqp.Config) error {
r.Lock()
// already connected
if r.connected {
r.Unlock()
return nil
}
// check it was closed
select {
case <-r.close:
r.close = make(chan bool)
default:
// no op
// new conn
}
r.Unlock()
return r.connect(secure, config)
}
func (r *rabbitMQConn) Close() error {
r.Lock()
defer r.Unlock()
select {
case <-r.close:
return nil
default:
close(r.close)
r.connected = false
}
return r.Connection.Close()
}
func (r *rabbitMQConn) tryConnect(secure bool, config *amqp.Config) error {
var err error
if config == nil {
config = &defaultAmqpConfig
}
url := r.url
if secure || config.TLSClientConfig != nil || strings.HasPrefix(r.url, "amqps://") {
if config.TLSClientConfig == nil {
config.TLSClientConfig = &tls.Config{
InsecureSkipVerify: true,
}
}
url = strings.Replace(r.url, "amqp://", "amqps://", 1)
}
r.Connection, err = dialConfig(url, *config)
if err != nil {
return err
}
if r.Channel, err = newRabbitChannel(r.Connection, r.prefetchCount, r.prefetchGlobal, r.confirmPublish); err != nil {
return err
}
if !r.withoutExchange {
if r.exchange.Durable {
r.Channel.DeclareDurableExchange(r.exchange)
} else {
r.Channel.DeclareExchange(r.exchange)
}
r.ExchangeChannel, err = newRabbitChannel(r.Connection, r.prefetchCount, r.prefetchGlobal, r.confirmPublish)
}
return err
}
func (r *rabbitMQConn) Consume(queue, key string, headers amqp.Table, qArgs amqp.Table, autoAck, durableQueue bool) (*rabbitMQChannel, <-chan amqp.Delivery, error) {
consumerChannel, err := newRabbitChannel(r.Connection, r.prefetchCount, r.prefetchGlobal, r.confirmPublish)
if err != nil {
return nil, nil, err
}
if durableQueue {
err = consumerChannel.DeclareDurableQueue(queue, qArgs)
} else {
err = consumerChannel.DeclareQueue(queue, qArgs)
}
if err != nil {
return nil, nil, err
}
deliveries, err := consumerChannel.ConsumeQueue(queue, autoAck)
if err != nil {
return nil, nil, err
}
if !r.withoutExchange {
err = consumerChannel.BindQueue(queue, key, r.exchange.Name, headers)
if err != nil {
return nil, nil, err
}
}
return consumerChannel, deliveries, nil
}
func (r *rabbitMQConn) Publish(exchange, key string, msg amqp.Publishing) error {
if r.withoutExchange {
return r.Channel.Publish("", key, msg)
}
return r.ExchangeChannel.Publish(exchange, key, msg)
}

111
broker/rabbitmq/connection_test.go Normal file
View File

@ -0,0 +1,111 @@
package rabbitmq
import (
"crypto/tls"
"errors"
"testing"
"github.com/streadway/amqp"
"go-micro.dev/v5/logger"
)
func TestNewRabbitMQConnURL(t *testing.T) {
testcases := []struct {
title string
urls []string
want string
}{
{"Multiple URLs", []string{"amqp://example.com/one", "amqp://example.com/two"}, "amqp://example.com/one"},
{"Insecure URL", []string{"amqp://example.com"}, "amqp://example.com"},
{"Secure URL", []string{"amqps://example.com"}, "amqps://example.com"},
{"Invalid URL", []string{"http://example.com"}, DefaultRabbitURL},
{"No URLs", []string{}, DefaultRabbitURL},
}
for _, test := range testcases {
conn := newRabbitMQConn(Exchange{Name: "exchange"}, test.urls, 0, false, false, false, logger.DefaultLogger)
if have, want := conn.url, test.want; have != want {
t.Errorf("%s: invalid url, want %q, have %q", test.title, want, have)
}
}
}
func TestTryToConnectTLS(t *testing.T) {
var (
dialCount, dialTLSCount int
err = errors.New("stop connect here")
)
dialConfig = func(_ string, c amqp.Config) (*amqp.Connection, error) {
if c.TLSClientConfig != nil {
dialTLSCount++
return nil, err
}
dialCount++
return nil, err
}
testcases := []struct {
title string
url string
secure bool
amqpConfig *amqp.Config
wantTLS bool
}{
{"unsecure url, secure false, no tls config", "amqp://example.com", false, nil, false},
{"secure url, secure false, no tls config", "amqps://example.com", false, nil, true},
{"unsecure url, secure true, no tls config", "amqp://example.com", true, nil, true},
{"unsecure url, secure false, tls config", "amqp://example.com", false, &amqp.Config{TLSClientConfig: &tls.Config{}}, true},
}
for _, test := range testcases {
dialCount, dialTLSCount = 0, 0
conn := newRabbitMQConn(Exchange{Name: "exchange"}, []string{test.url}, 0, false, false, false, logger.DefaultLogger)
conn.tryConnect(test.secure, test.amqpConfig)
have := dialCount
if test.wantTLS {
have = dialTLSCount
}
if have != 1 {
t.Errorf("%s: used wrong dialer, Dial called %d times, DialTLS called %d times", test.title, dialCount, dialTLSCount)
}
}
}
func TestNewRabbitMQPrefetchConfirmPublish(t *testing.T) {
testcases := []struct {
title string
urls []string
prefetchCount int
prefetchGlobal bool
confirmPublish bool
}{
{"Multiple URLs", []string{"amqp://example.com/one", "amqp://example.com/two"}, 1, true, true},
{"Insecure URL", []string{"amqp://example.com"}, 1, true, true},
{"Secure URL", []string{"amqps://example.com"}, 1, true, true},
{"Invalid URL", []string{"http://example.com"}, 1, true, true},
{"No URLs", []string{}, 1, true, true},
}
for _, test := range testcases {
conn := newRabbitMQConn(Exchange{Name: "exchange"}, test.urls, test.prefetchCount, test.prefetchGlobal, test.confirmPublish, false, logger.DefaultLogger)
if have, want := conn.prefetchCount, test.prefetchCount; have != want {
t.Errorf("%s: invalid prefetch count, want %d, have %d", test.title, want, have)
}
if have, want := conn.prefetchGlobal, test.prefetchGlobal; have != want {
t.Errorf("%s: invalid prefetch global setting, want %t, have %t", test.title, want, have)
}
if have, want := conn.confirmPublish, test.confirmPublish; have != want {
t.Errorf("%s: invalid confirm setting, want %t, have %t", test.title, want, have)
}
}
}

48
broker/rabbitmq/context.go Normal file
View File

@ -0,0 +1,48 @@
package rabbitmq
import (
"context"
"go-micro.dev/v5/broker"
"go-micro.dev/v5/server"
)
// setSubscribeOption returns a function to setup a context with given value.
func setSubscribeOption(k, v interface{}) broker.SubscribeOption {
return func(o *broker.SubscribeOptions) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, k, v)
}
}
// setBrokerOption returns a function to setup a context with given value.
func setBrokerOption(k, v interface{}) broker.Option {
return func(o *broker.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, k, v)
}
}
// setBrokerOption returns a function to setup a context with given value.
func setServerSubscriberOption(k, v interface{}) server.SubscriberOption {
return func(o *server.SubscriberOptions) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, k, v)
}
}
// setPublishOption returns a function to setup a context with given value.
func setPublishOption(k, v interface{}) broker.PublishOption {
return func(o *broker.PublishOptions) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, k, v)
}
}

189
broker/rabbitmq/options.go Normal file
View File

@ -0,0 +1,189 @@
package rabbitmq
import (
"context"
"time"
"go-micro.dev/v5/broker"
"go-micro.dev/v5/client"
"go-micro.dev/v5/server"
)
type durableQueueKey struct{}
type headersKey struct{}
type queueArgumentsKey struct{}
type prefetchCountKey struct{}
type prefetchGlobalKey struct{}
type confirmPublishKey struct{}
type exchangeKey struct{}
type exchangeTypeKey struct{}
type withoutExchangeKey struct{}
type requeueOnErrorKey struct{}
type deliveryMode struct{}
type priorityKey struct{}
type contentType struct{}
type contentEncoding struct{}
type correlationID struct{}
type replyTo struct{}
type expiration struct{}
type messageID struct{}
type timestamp struct{}
type typeMsg struct{}
type userID struct{}
type appID struct{}
type externalAuth struct{}
type durableExchange struct{}
// ServerDurableQueue provide durable queue option for micro.RegisterSubscriber
func ServerDurableQueue() server.SubscriberOption {
return setServerSubscriberOption(durableQueueKey{}, true)
}
// ServerAckOnSuccess export AckOnSuccess server.SubscriberOption
func ServerAckOnSuccess() server.SubscriberOption {
return setServerSubscriberOption(ackSuccessKey{}, true)
}
// DurableQueue creates a durable queue when subscribing.
func DurableQueue() broker.SubscribeOption {
return setSubscribeOption(durableQueueKey{}, true)
}
// DurableExchange is an option to set the Exchange to be durable.
func DurableExchange() broker.Option {
return setBrokerOption(durableExchange{}, true)
}
// Headers adds headers used by the headers exchange.
func Headers(h map[string]interface{}) broker.SubscribeOption {
return setSubscribeOption(headersKey{}, h)
}
// QueueArguments sets arguments for queue creation.
func QueueArguments(h map[string]interface{}) broker.SubscribeOption {
return setSubscribeOption(queueArgumentsKey{}, h)
}
func RequeueOnError() broker.SubscribeOption {
return setSubscribeOption(requeueOnErrorKey{}, true)
}
// ExchangeName is an option to set the ExchangeName.
func ExchangeName(e string) broker.Option {
return setBrokerOption(exchangeKey{}, e)
}
// WithoutExchange is an option to use the rabbitmq default exchange.
// means it would not create any custom exchange.
func WithoutExchange() broker.Option {
return setBrokerOption(withoutExchangeKey{}, true)
}
// ExchangeType is an option to set the rabbitmq exchange type.
func ExchangeType(t MQExchangeType) broker.Option {
return setBrokerOption(exchangeTypeKey{}, t)
}
// PrefetchCount ...
func PrefetchCount(c int) broker.Option {
return setBrokerOption(prefetchCountKey{}, c)
}
// PrefetchGlobal creates a durable queue when subscribing.
func PrefetchGlobal() broker.Option {
return setBrokerOption(prefetchGlobalKey{}, true)
}
// ConfirmPublish ensures all published messages are confirmed by waiting for an ack/nack from the broker.
func ConfirmPublish() broker.Option {
return setBrokerOption(confirmPublishKey{}, true)
}
// DeliveryMode sets a delivery mode for publishing.
func DeliveryMode(value uint8) broker.PublishOption {
return setPublishOption(deliveryMode{}, value)
}
// Priority sets a priority level for publishing.
func Priority(value uint8) broker.PublishOption {
return setPublishOption(priorityKey{}, value)
}
// ContentType sets a property MIME content type for publishing.
func ContentType(value string) broker.PublishOption {
return setPublishOption(contentType{}, value)
}
// ContentEncoding sets a property MIME content encoding for publishing.
func ContentEncoding(value string) broker.PublishOption {
return setPublishOption(contentEncoding{}, value)
}
// CorrelationID sets a property correlation ID for publishing.
func CorrelationID(value string) broker.PublishOption {
return setPublishOption(correlationID{}, value)
}
// ReplyTo sets a property address to to reply to (ex: RPC) for publishing.
func ReplyTo(value string) broker.PublishOption {
return setPublishOption(replyTo{}, value)
}
// Expiration sets a property message expiration spec for publishing.
func Expiration(value string) broker.PublishOption {
return setPublishOption(expiration{}, value)
}
// MessageId sets a property message identifier for publishing.
func MessageId(value string) broker.PublishOption {
return setPublishOption(messageID{}, value)
}
// Timestamp sets a property message timestamp for publishing.
func Timestamp(value time.Time) broker.PublishOption {
return setPublishOption(timestamp{}, value)
}
// TypeMsg sets a property message type name for publishing.
func TypeMsg(value string) broker.PublishOption {
return setPublishOption(typeMsg{}, value)
}
// UserID sets a property user id for publishing.
func UserID(value string) broker.PublishOption {
return setPublishOption(userID{}, value)
}
// AppID sets a property application id for publishing.
func AppID(value string) broker.PublishOption {
return setPublishOption(appID{}, value)
}
func ExternalAuth() broker.Option {
return setBrokerOption(externalAuth{}, ExternalAuthentication{})
}
type subscribeContextKey struct{}
// SubscribeContext set the context for broker.SubscribeOption.
func SubscribeContext(ctx context.Context) broker.SubscribeOption {
return setSubscribeOption(subscribeContextKey{}, ctx)
}
type ackSuccessKey struct{}
// AckOnSuccess will automatically acknowledge messages when no error is returned.
func AckOnSuccess() broker.SubscribeOption {
return setSubscribeOption(ackSuccessKey{}, true)
}
// PublishDeliveryMode client.PublishOption for setting message "delivery mode"
// mode , Transient (0 or 1) or Persistent (2)
func PublishDeliveryMode(mode uint8) client.PublishOption {
return func(o *client.PublishOptions) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, deliveryMode{}, mode)
}
}

445
broker/rabbitmq/rabbitmq.go Normal file
View File

@ -0,0 +1,445 @@
// Package rabbitmq provides a RabbitMQ broker
package rabbitmq
import (
"context"
"errors"
"fmt"
"net/url"
"sync"
"time"
"github.com/streadway/amqp"
"go-micro.dev/v5/broker"
"go-micro.dev/v5/logger"
)
type rbroker struct {
conn *rabbitMQConn
addrs []string
opts broker.Options
prefetchCount int
prefetchGlobal bool
mtx sync.Mutex
wg sync.WaitGroup
}
type subscriber struct {
mtx sync.Mutex
unsub chan bool
opts broker.SubscribeOptions
topic string
ch *rabbitMQChannel
durableQueue bool
queueArgs map[string]interface{}
r *rbroker
fn func(msg amqp.Delivery)
headers map[string]interface{}
wg sync.WaitGroup
}
type publication struct {
d amqp.Delivery
m *broker.Message
t string
err error
}
func (p *publication) Ack() error {
return p.d.Ack(false)
}
func (p *publication) Error() error {
return p.err
}
func (p *publication) Topic() string {
return p.t
}
func (p *publication) Message() *broker.Message {
return p.m
}
func (s *subscriber) Options() broker.SubscribeOptions {
return s.opts
}
func (s *subscriber) Topic() string {
return s.topic
}
func (s *subscriber) Unsubscribe() error {
s.unsub <- true
// Need to wait on subscriber to exit if autoack is disabled
// since closing the channel will prevent the ack/nack from
// being sent upon handler completion.
if !s.opts.AutoAck {
s.wg.Wait()
}
s.mtx.Lock()
defer s.mtx.Unlock()
if s.ch != nil {
return s.ch.Close()
}
return nil
}
func (s *subscriber) resubscribe() {
s.wg.Add(1)
defer s.wg.Done()
minResubscribeDelay := 100 * time.Millisecond
maxResubscribeDelay := 30 * time.Second
expFactor := time.Duration(2)
reSubscribeDelay := minResubscribeDelay
// loop until unsubscribe
for {
select {
// unsubscribe case
case <-s.unsub:
return
// check shutdown case
case <-s.r.conn.close:
// yep, its shutdown case
return
// wait until we reconect to rabbit
case <-s.r.conn.waitConnection:
// When the connection is disconnected, the waitConnection will be re-assigned, so '<-s.r.conn.waitConnection' maybe blocked.
// Here, it returns once a second, and then the latest waitconnection will be used
case <-time.After(time.Second):
continue
}
// it may crash (panic) in case of Consume without connection, so recheck it
s.r.mtx.Lock()
if !s.r.conn.connected {
s.r.mtx.Unlock()
continue
}
ch, sub, err := s.r.conn.Consume(
s.opts.Queue,
s.topic,
s.headers,
s.queueArgs,
s.opts.AutoAck,
s.durableQueue,
)
s.r.mtx.Unlock()
switch err {
case nil:
reSubscribeDelay = minResubscribeDelay
s.mtx.Lock()
s.ch = ch
s.mtx.Unlock()
default:
if reSubscribeDelay > maxResubscribeDelay {
reSubscribeDelay = maxResubscribeDelay
}
time.Sleep(reSubscribeDelay)
reSubscribeDelay *= expFactor
continue
}
SubLoop:
for {
select {
case <-s.unsub:
return
case d, ok := <-sub:
if !ok {
break SubLoop
}
s.r.wg.Add(1)
s.fn(d)
s.r.wg.Done()
}
}
}
}
func (r *rbroker) Publish(topic string, msg *broker.Message, opts ...broker.PublishOption) error {
m := amqp.Publishing{
Body: msg.Body,
Headers: amqp.Table{},
}
options := broker.PublishOptions{}
for _, o := range opts {
o(&options)
}
if options.Context != nil {
if value, ok := options.Context.Value(deliveryMode{}).(uint8); ok {
m.DeliveryMode = value
}
if value, ok := options.Context.Value(priorityKey{}).(uint8); ok {
m.Priority = value
}
if value, ok := options.Context.Value(contentType{}).(string); ok {
m.Headers["Content-Type"] = value
m.ContentType = value
}
if value, ok := options.Context.Value(contentEncoding{}).(string); ok {
m.ContentEncoding = value
}
if value, ok := options.Context.Value(correlationID{}).(string); ok {
m.CorrelationId = value
}
if value, ok := options.Context.Value(replyTo{}).(string); ok {
m.ReplyTo = value
}
if value, ok := options.Context.Value(expiration{}).(string); ok {
m.Expiration = value
}
if value, ok := options.Context.Value(messageID{}).(string); ok {
m.MessageId = value
}
if value, ok := options.Context.Value(timestamp{}).(time.Time); ok {
m.Timestamp = value
}
if value, ok := options.Context.Value(typeMsg{}).(string); ok {
m.Type = value
}
if value, ok := options.Context.Value(userID{}).(string); ok {
m.UserId = value
}
if value, ok := options.Context.Value(appID{}).(string); ok {
m.AppId = value
}
}
for k, v := range msg.Header {
m.Headers[k] = v
}
if r.getWithoutExchange() {
m.Headers["Micro-Topic"] = topic
}
if r.conn == nil {
return errors.New("connection is nil")
}
return r.conn.Publish(r.conn.exchange.Name, topic, m)
}
func (r *rbroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
var ackSuccess bool
if r.conn == nil {
return nil, errors.New("not connected")
}
opt := broker.SubscribeOptions{
AutoAck: true,
}
for _, o := range opts {
o(&opt)
}
// Make sure context is setup
if opt.Context == nil {
opt.Context = context.Background()
}
ctx := opt.Context
if subscribeContext, ok := ctx.Value(subscribeContextKey{}).(context.Context); ok && subscribeContext != nil {
ctx = subscribeContext
}
var requeueOnError bool
requeueOnError, _ = ctx.Value(requeueOnErrorKey{}).(bool)
var durableQueue bool
durableQueue, _ = ctx.Value(durableQueueKey{}).(bool)
var qArgs map[string]interface{}
if qa, ok := ctx.Value(queueArgumentsKey{}).(map[string]interface{}); ok {
qArgs = qa
}
var headers map[string]interface{}
if h, ok := ctx.Value(headersKey{}).(map[string]interface{}); ok {
headers = h
}
if bval, ok := ctx.Value(ackSuccessKey{}).(bool); ok && bval {
opt.AutoAck = false
ackSuccess = true
}
fn := func(msg amqp.Delivery) {
header := make(map[string]string)
for k, v := range msg.Headers {
header[k] = fmt.Sprintf("%v", v)
}
// Get rid of dependence on 'Micro-Topic'
msgTopic := header["Micro-Topic"]
if msgTopic == "" {
header["Micro-Topic"] = msg.RoutingKey
}
m := &broker.Message{
Header: header,
Body: msg.Body,
}
p := &publication{d: msg, m: m, t: msg.RoutingKey}
p.err = handler(p)
if p.err == nil && ackSuccess && !opt.AutoAck {
msg.Ack(false)
} else if p.err != nil && !opt.AutoAck {
msg.Nack(false, requeueOnError)
}
}
sret := &subscriber{topic: topic, opts: opt, unsub: make(chan bool), r: r,
durableQueue: durableQueue, fn: fn, headers: headers, queueArgs: qArgs,
wg: sync.WaitGroup{}}
go sret.resubscribe()
return sret, nil
}
func (r *rbroker) Options() broker.Options {
return r.opts
}
func (r *rbroker) String() string {
return "rabbitmq"
}
func (r *rbroker) Address() string {
if len(r.addrs) > 0 {
u, err := url.Parse(r.addrs[0])
if err != nil {
return ""
}
return u.Redacted()
}
return ""
}
func (r *rbroker) Init(opts ...broker.Option) error {
for _, o := range opts {
o(&r.opts)
}
r.addrs = r.opts.Addrs
return nil
}
func (r *rbroker) Connect() error {
if r.conn == nil {
r.conn = newRabbitMQConn(
r.getExchange(),
r.opts.Addrs,
r.getPrefetchCount(),
r.getPrefetchGlobal(),
r.getConfirmPublish(),
r.getWithoutExchange(),
r.opts.Logger,
)
}
conf := defaultAmqpConfig
if auth, ok := r.opts.Context.Value(externalAuth{}).(ExternalAuthentication); ok {
conf.SASL = []amqp.Authentication{&auth}
}
conf.TLSClientConfig = r.opts.TLSConfig
return r.conn.Connect(r.opts.Secure, &conf)
}
func (r *rbroker) Disconnect() error {
if r.conn == nil {
return errors.New("connection is nil")
}
ret := r.conn.Close()
r.wg.Wait() // wait all goroutines
return ret
}
func NewBroker(opts ...broker.Option) broker.Broker {
options := broker.Options{
Context: context.Background(),
Logger: logger.DefaultLogger,
}
for _, o := range opts {
o(&options)
}
return &rbroker{
addrs: options.Addrs,
opts: options,
}
}
func (r *rbroker) getExchange() Exchange {
ex := DefaultExchange
if e, ok := r.opts.Context.Value(exchangeKey{}).(string); ok {
ex.Name = e
}
if t, ok := r.opts.Context.Value(exchangeTypeKey{}).(MQExchangeType); ok {
ex.Type = t
}
if d, ok := r.opts.Context.Value(durableExchange{}).(bool); ok {
ex.Durable = d
}
return ex
}
func (r *rbroker) getPrefetchCount() int {
if e, ok := r.opts.Context.Value(prefetchCountKey{}).(int); ok {
return e
}
return DefaultPrefetchCount
}
func (r *rbroker) getPrefetchGlobal() bool {
if e, ok := r.opts.Context.Value(prefetchGlobalKey{}).(bool); ok {
return e
}
return DefaultPrefetchGlobal
}
func (r *rbroker) getConfirmPublish() bool {
if e, ok := r.opts.Context.Value(confirmPublishKey{}).(bool); ok {
return e
}
return DefaultConfirmPublish
}
func (r *rbroker) getWithoutExchange() bool {
if e, ok := r.opts.Context.Value(withoutExchangeKey{}).(bool); ok {
return e
}
return DefaultWithoutExchange
}

305
broker/rabbitmq/rabbitmq_test.go Normal file
View File

@ -0,0 +1,305 @@
package rabbitmq_test
import (
"context"
"encoding/json"
"os"
"testing"
"time"
"go-micro.dev/v5/logger"
micro "go-micro.dev/v5"
broker "go-micro.dev/v5/broker"
rabbitmq "go-micro.dev/v5/broker/rabbitmq"
server "go-micro.dev/v5/server"
)
type Example struct{}
func init() {
rabbitmq.DefaultRabbitURL = "amqp://rabbitmq:rabbitmq@127.0.0.1:5672"
}
type TestEvent struct {
Name string `json:"name"`
Age int `json:"age"`
Time time.Time `json:"time"`
}
func (e *Example) Handler(ctx context.Context, r interface{}) error {
return nil
}
func TestDurable(t *testing.T) {
if tr := os.Getenv("TRAVIS"); len(tr) > 0 {
t.Skip()
}
brkrSub := broker.NewSubscribeOptions(
broker.Queue("queue.default"),
broker.DisableAutoAck(),
rabbitmq.DurableQueue(),
)
b := rabbitmq.NewBroker()
b.Init()
if err := b.Connect(); err != nil {
t.Logf("cant conect to broker, skip: %v", err)
t.Skip()
}
s := server.NewServer(server.Broker(b))
service := micro.NewService(
micro.Server(s),
micro.Broker(b),
)
h := &Example{}
// Register a subscriber
micro.RegisterSubscriber(
"topic",
service.Server(),
h.Handler,
server.SubscriberContext(brkrSub.Context),
server.SubscriberQueue("queue.default"),
)
// service.Init()
if err := service.Run(); err != nil {
t.Fatal(err)
}
}
func TestWithoutExchange(t *testing.T) {
b := rabbitmq.NewBroker(rabbitmq.WithoutExchange())
b.Init()
if err := b.Connect(); err != nil {
t.Logf("cant conect to broker, skip: %v", err)
t.Skip()
}
s := server.NewServer(server.Broker(b))
service := micro.NewService(
micro.Server(s),
micro.Broker(b),
)
brkrSub := broker.NewSubscribeOptions(
broker.Queue("direct.queue"),
broker.DisableAutoAck(),
rabbitmq.DurableQueue(),
)
// Register a subscriber
err := micro.RegisterSubscriber(
"direct.queue",
service.Server(),
func(ctx context.Context, evt *TestEvent) error {
logger.Logf(logger.InfoLevel, "receive event: %+v", evt)
return nil
},
server.SubscriberContext(brkrSub.Context),
server.SubscriberQueue("direct.queue"),
)
if err != nil {
t.Fatal(err)
}
go func() {
time.Sleep(5 * time.Second)
logger.Logf(logger.InfoLevel, "pub event")
jsonData, _ := json.Marshal(&TestEvent{
Name: "test",
Age: 16,
})
err := b.Publish("direct.queue", &broker.Message{
Body: jsonData,
},
rabbitmq.DeliveryMode(2),
rabbitmq.ContentType("application/json"))
if err != nil {
t.Fatal(err)
}
}()
// service.Init()
if err := service.Run(); err != nil {
t.Fatal(err)
}
}
func TestFanoutExchange(t *testing.T) {
b := rabbitmq.NewBroker(rabbitmq.ExchangeType(rabbitmq.ExchangeTypeFanout), rabbitmq.ExchangeName("fanout.test"))
b.Init()
if err := b.Connect(); err != nil {
t.Logf("cant conect to broker, skip: %v", err)
t.Skip()
}
s := server.NewServer(server.Broker(b))
service := micro.NewService(
micro.Server(s),
micro.Broker(b),
)
brkrSub := broker.NewSubscribeOptions(
broker.Queue("fanout.queue"),
broker.DisableAutoAck(),
rabbitmq.DurableQueue(),
)
// Register a subscriber
err := micro.RegisterSubscriber(
"fanout.queue",
service.Server(),
func(ctx context.Context, evt *TestEvent) error {
logger.Logf(logger.InfoLevel, "receive event: %+v", evt)
return nil
},
server.SubscriberContext(brkrSub.Context),
server.SubscriberQueue("fanout.queue"),
)
if err != nil {
t.Fatal(err)
}
go func() {
time.Sleep(5 * time.Second)
logger.Logf(logger.InfoLevel, "pub event")
jsonData, _ := json.Marshal(&TestEvent{
Name: "test",
Age: 16,
})
err := b.Publish("fanout.queue", &broker.Message{
Body: jsonData,
},
rabbitmq.DeliveryMode(2),
rabbitmq.ContentType("application/json"))
if err != nil {
t.Fatal(err)
}
}()
// service.Init()
if err := service.Run(); err != nil {
t.Fatal(err)
}
}
func TestDirectExchange(t *testing.T) {
b := rabbitmq.NewBroker(rabbitmq.ExchangeType(rabbitmq.ExchangeTypeDirect), rabbitmq.ExchangeName("direct.test"))
b.Init()
if err := b.Connect(); err != nil {
t.Logf("cant conect to broker, skip: %v", err)
t.Skip()
}
s := server.NewServer(server.Broker(b))
service := micro.NewService(
micro.Server(s),
micro.Broker(b),
)
brkrSub := broker.NewSubscribeOptions(
broker.Queue("direct.exchange.queue"),
broker.DisableAutoAck(),
rabbitmq.DurableQueue(),
)
// Register a subscriber
err := micro.RegisterSubscriber(
"direct.exchange.queue",
service.Server(),
func(ctx context.Context, evt *TestEvent) error {
logger.Logf(logger.InfoLevel, "receive event: %+v", evt)
return nil
},
server.SubscriberContext(brkrSub.Context),
server.SubscriberQueue("direct.exchange.queue"),
)
if err != nil {
t.Fatal(err)
}
go func() {
time.Sleep(5 * time.Second)
logger.Logf(logger.InfoLevel, "pub event")
jsonData, _ := json.Marshal(&TestEvent{
Name: "test",
Age: 16,
})
err := b.Publish("direct.exchange.queue", &broker.Message{
Body: jsonData,
},
rabbitmq.DeliveryMode(2),
rabbitmq.ContentType("application/json"))
if err != nil {
t.Fatal(err)
}
}()
// service.Init()
if err := service.Run(); err != nil {
t.Fatal(err)
}
}
func TestTopicExchange(t *testing.T) {
b := rabbitmq.NewBroker()
b.Init()
if err := b.Connect(); err != nil {
t.Logf("cant conect to broker, skip: %v", err)
t.Skip()
}
s := server.NewServer(server.Broker(b))
service := micro.NewService(
micro.Server(s),
micro.Broker(b),
)
brkrSub := broker.NewSubscribeOptions(
broker.Queue("topic.exchange.queue"),
broker.DisableAutoAck(),
rabbitmq.DurableQueue(),
)
// Register a subscriber
err := micro.RegisterSubscriber(
"my-test-topic",
service.Server(),
func(ctx context.Context, evt *TestEvent) error {
logger.Logf(logger.InfoLevel, "receive event: %+v", evt)
return nil
},
server.SubscriberContext(brkrSub.Context),
server.SubscriberQueue("topic.exchange.queue"),
)
if err != nil {
t.Fatal(err)
}
go func() {
time.Sleep(5 * time.Second)
logger.Logf(logger.InfoLevel, "pub event")
jsonData, _ := json.Marshal(&TestEvent{
Name: "test",
Age: 16,
})
err := b.Publish("my-test-topic", &broker.Message{
Body: jsonData,
},
rabbitmq.DeliveryMode(2),
rabbitmq.ContentType("application/json"))
if err != nil {
t.Fatal(err)
}
}()
// service.Init()
if err := service.Run(); err != nil {
t.Fatal(err)
}
}

251
cmd/cmd.go
View File

@ -11,8 +11,8 @@ import (
"github.com/urfave/cli/v2"
"go-micro.dev/v5/auth"
hbroker "go-micro.dev/v5/broker/http"
nbroker "go-micro.dev/v5/broker/nats"
rabbit "go-micro.dev/v5/broker/rabbitmq"
"go-micro.dev/v5/broker"
"go-micro.dev/v5/cache"
@ -33,7 +33,10 @@ import (
"go-micro.dev/v5/server"
"go-micro.dev/v5/store"
"go-micro.dev/v5/store/mysql"
natsjskv "go-micro.dev/v5/store/nats-js-kv"
postgres "go-micro.dev/v5/store/postgres"
"go-micro.dev/v5/transport"
ntransport "go-micro.dev/v5/transport/nats"
)
type Cmd interface {
@ -146,6 +149,11 @@ var (
Usage: "Plugin profile to use. (local, nats, etc)",
EnvVars: []string{"MICRO_PROFILE"},
},
&cli.StringFlag{
Name: "debug-profile",
Usage: "Debug Plugin profile to use.",
EnvVars: []string{"MICRO_DEBUG_PROFILE"},
},
&cli.StringFlag{
Name: "registry",
EnvVars: []string{"MICRO_REGISTRY"},
@ -240,9 +248,10 @@ var (
}
DefaultBrokers = map[string]func(...broker.Option) broker.Broker{
"memory": broker.NewMemoryBroker,
"http": hbroker.NewHttpBroker,
"nats": nbroker.NewNatsBroker,
"memory": broker.NewMemoryBroker,
"http": broker.NewHttpBroker,
"nats": nbroker.NewNatsBroker,
"rabbitmq": rabbit.NewBroker,
}
DefaultClients = map[string]func(...client.Option) client.Client{}
@ -259,18 +268,22 @@ var (
DefaultServers = map[string]func(...server.Option) server.Server{}
DefaultTransports = map[string]func(...transport.Option) transport.Transport{}
DefaultTransports = map[string]func(...transport.Option) transport.Transport{
"nats": ntransport.NewTransport,
}
DefaultStores = map[string]func(...store.Option) store.Store{
"memory": store.NewMemoryStore,
"mysql": mysql.NewMysqlStore,
"memory": store.NewMemoryStore,
"mysql": mysql.NewMysqlStore,
"natsjskv": natsjskv.NewStore,
"postgres": postgres.NewStore,
}
DefaultTracers = map[string]func(...trace.Option) trace.Tracer{}
DefaultAuths = map[string]func(...auth.Option) auth.Auth{}
DefaultProfiles = map[string]func(...profile.Option) profile.Profile{
DefaultDebugProfiles = map[string]func(...profile.Option) profile.Profile{
"http": http.NewProfile,
"pprof": pprof.NewProfile,
}
@ -288,31 +301,31 @@ func init() {
func newCmd(opts ...Option) Cmd {
options := Options{
Auth: &auth.DefaultAuth,
Broker: &broker.DefaultBroker,
Client: &client.DefaultClient,
Registry: &registry.DefaultRegistry,
Server: &server.DefaultServer,
Selector: &selector.DefaultSelector,
Transport: &transport.DefaultTransport,
Store: &store.DefaultStore,
Tracer: &trace.DefaultTracer,
Profile: &profile.DefaultProfile,
Config: &config.DefaultConfig,
Cache: &cache.DefaultCache,
Auth: &auth.DefaultAuth,
Broker: &broker.DefaultBroker,
Client: &client.DefaultClient,
Registry: &registry.DefaultRegistry,
Server: &server.DefaultServer,
Selector: &selector.DefaultSelector,
Transport: &transport.DefaultTransport,
Store: &store.DefaultStore,
Tracer: &trace.DefaultTracer,
DebugProfile: &profile.DefaultProfile,
Config: &config.DefaultConfig,
Cache: &cache.DefaultCache,
Brokers: DefaultBrokers,
Clients: DefaultClients,
Registries: DefaultRegistries,
Selectors: DefaultSelectors,
Servers: DefaultServers,
Transports: DefaultTransports,
Stores: DefaultStores,
Tracers: DefaultTracers,
Auths: DefaultAuths,
Profiles: DefaultProfiles,
Configs: DefaultConfigs,
Caches: DefaultCaches,
Brokers: DefaultBrokers,
Clients: DefaultClients,
Registries: DefaultRegistries,
Selectors: DefaultSelectors,
Servers: DefaultServers,
Transports: DefaultTransports,
Stores: DefaultStores,
Tracers: DefaultTracers,
Auths: DefaultAuths,
DebugProfiles: DefaultDebugProfiles,
Configs: DefaultConfigs,
Caches: DefaultCaches,
}
for _, o := range opts {
@ -354,12 +367,57 @@ func (c *cmd) Before(ctx *cli.Context) error {
// If flags are set then use them otherwise do nothing
var serverOpts []server.Option
var clientOpts []client.Option
// --- Profile Grouping Extension ---
profileName := ctx.String("profile")
if profileName == "" {
profileName = os.Getenv("MICRO_PROFILE")
}
if profileName != "" {
switch profileName {
case "local":
imported := mprofile.LocalProfile()
*c.opts.Registry = imported.Registry
registry.DefaultRegistry = imported.Registry
*c.opts.Broker = imported.Broker
broker.DefaultBroker = imported.Broker
*c.opts.Store = imported.Store
store.DefaultStore = imported.Store
*c.opts.Transport = imported.Transport
transport.DefaultTransport = imported.Transport
case "nats":
imported := mprofile.NatsProfile()
// Set the registry
sopts, clopts := c.setRegistry(imported.Registry)
serverOpts = append(serverOpts, sopts...)
clientOpts = append(clientOpts, clopts...)
// set the store
sopts, clopts = c.setStore(imported.Store)
serverOpts = append(serverOpts, sopts...)
clientOpts = append(clientOpts, clopts...)
// set the transport
sopts, clopts = c.setTransport(imported.Transport)
serverOpts = append(serverOpts, sopts...)
clientOpts = append(clientOpts, clopts...)
// Set the broker
sopts, clopts = c.setBroker(imported.Broker)
serverOpts = append(serverOpts, sopts...)
clientOpts = append(clientOpts, clopts...)
// Add more profiles as needed
default:
return fmt.Errorf("unsupported profile: %s", profileName)
}
}
// Set the client
if name := ctx.String("client"); len(name) > 0 {
// only change if we have the client and type differs
if cl, ok := c.opts.Clients[name]; ok && (*c.opts.Client).String() != name {
*c.opts.Client = cl()
client.DefaultClient = *c.opts.Client
}
}
@ -368,6 +426,7 @@ func (c *cmd) Before(ctx *cli.Context) error {
// only change if we have the server and type differs
if s, ok := c.opts.Servers[name]; ok && (*c.opts.Server).String() != name {
*c.opts.Server = s()
server.DefaultServer = *c.opts.Server
}
}
@ -379,6 +438,7 @@ func (c *cmd) Before(ctx *cli.Context) error {
}
*c.opts.Store = s(store.WithClient(*c.opts.Client))
store.DefaultStore = *c.opts.Store
}
// Set the tracer
@ -389,6 +449,7 @@ func (c *cmd) Before(ctx *cli.Context) error {
}
*c.opts.Tracer = r()
trace.DefaultTracer = *c.opts.Tracer
}
// Setup auth
@ -415,6 +476,7 @@ func (c *cmd) Before(ctx *cli.Context) error {
}
*c.opts.Auth = r(authOpts...)
auth.DefaultAuth = *c.opts.Auth
}
// Set the registry
@ -424,63 +486,19 @@ func (c *cmd) Before(ctx *cli.Context) error {
return fmt.Errorf("Registry %s not found", name)
}
*c.opts.Registry = r()
serverOpts = append(serverOpts, server.Registry(*c.opts.Registry))
clientOpts = append(clientOpts, client.Registry(*c.opts.Registry))
if err := (*c.opts.Selector).Init(selector.Registry(*c.opts.Registry)); err != nil {
logger.Fatalf("Error configuring registry: %v", err)
}
clientOpts = append(clientOpts, client.Selector(*c.opts.Selector))
if err := (*c.opts.Broker).Init(broker.Registry(*c.opts.Registry)); err != nil {
logger.Fatalf("Error configuring broker: %v", err)
}
sopts, clopts := c.setRegistry(r())
serverOpts = append(serverOpts, sopts...)
clientOpts = append(clientOpts, clopts...)
}
// --- Profile Grouping Extension ---
// Check for new profile flag/env (not just debug profiler)
profileName := ctx.String("profile")
if profileName == "" {
profileName = os.Getenv("MICRO_PROFILE")
}
if profileName != "" {
switch profileName {
case "local":
imported := mprofile.LocalProfile()
*c.opts.Registry = imported.Registry
registry.DefaultRegistry = imported.Registry
*c.opts.Broker = imported.Broker
broker.DefaultBroker = imported.Broker
*c.opts.Store = imported.Store
store.DefaultStore = imported.Store
*c.opts.Transport = imported.Transport
transport.DefaultTransport = imported.Transport
case "nats":
imported := mprofile.NatsProfile()
*c.opts.Registry = imported.Registry
registry.DefaultRegistry = imported.Registry
*c.opts.Broker = imported.Broker
broker.DefaultBroker = imported.Broker
*c.opts.Store = imported.Store
store.DefaultStore = imported.Store
*c.opts.Transport = imported.Transport
transport.DefaultTransport = imported.Transport
// Add more profiles as needed
default:
return fmt.Errorf("unsupported profile: %s", profileName)
}
}
// Set the profile
if name := ctx.String("profile"); len(name) > 0 {
p, ok := c.opts.Profiles[name]
// Set the debug profile
if name := ctx.String("debug-profile"); len(name) > 0 {
p, ok := c.opts.DebugProfiles[name]
if !ok {
return fmt.Errorf("unsupported profile: %s", name)
}
*c.opts.Profile = p()
*c.opts.DebugProfile = p()
profile.DefaultProfile = *c.opts.DebugProfile
}
// Set the broker
@ -489,10 +507,9 @@ func (c *cmd) Before(ctx *cli.Context) error {
if !ok {
return fmt.Errorf("Broker %s not found", name)
}
*c.opts.Broker = b()
serverOpts = append(serverOpts, server.Broker(*c.opts.Broker))
clientOpts = append(clientOpts, client.Broker(*c.opts.Broker))
sopts, clopts := c.setBroker(b())
serverOpts = append(serverOpts, sopts...)
clientOpts = append(clientOpts, clopts...)
}
// Set the selector
@ -506,6 +523,7 @@ func (c *cmd) Before(ctx *cli.Context) error {
// No server option here. Should there be?
clientOpts = append(clientOpts, client.Selector(*c.opts.Selector))
selector.DefaultSelector = *c.opts.Selector
}
// Set the transport
@ -515,9 +533,10 @@ func (c *cmd) Before(ctx *cli.Context) error {
return fmt.Errorf("Transport %s not found", name)
}
*c.opts.Transport = t()
serverOpts = append(serverOpts, server.Transport(*c.opts.Transport))
clientOpts = append(clientOpts, client.Transport(*c.opts.Transport))
sopts, clopts := c.setTransport(t())
serverOpts = append(serverOpts, sopts...)
clientOpts = append(clientOpts, clopts...)
}
// Parse the server options
@ -657,12 +676,60 @@ func (c *cmd) Before(ctx *cli.Context) error {
logger.Fatalf("Error configuring config: %v", err)
}
*c.opts.Config = rc
config.DefaultConfig = *c.opts.Config
}
}
return nil
}
func (c *cmd) setRegistry(r registry.Registry) ([]server.Option, []client.Option) {
var serverOpts []server.Option
var clientOpts []client.Option
*c.opts.Registry = r
serverOpts = append(serverOpts, server.Registry(*c.opts.Registry))
clientOpts = append(clientOpts, client.Registry(*c.opts.Registry))
if err := (*c.opts.Selector).Init(selector.Registry(*c.opts.Registry)); err != nil {
logger.Fatalf("Error configuring registry: %v", err)
}
clientOpts = append(clientOpts, client.Selector(*c.opts.Selector))
if err := (*c.opts.Broker).Init(broker.Registry(*c.opts.Registry)); err != nil {
logger.Fatalf("Error configuring broker: %v", err)
}
registry.DefaultRegistry = *c.opts.Registry
return serverOpts, clientOpts
}
func (c *cmd) setBroker(b broker.Broker) ([]server.Option, []client.Option) {
var serverOpts []server.Option
var clientOpts []client.Option
*c.opts.Broker = b
serverOpts = append(serverOpts, server.Broker(*c.opts.Broker))
clientOpts = append(clientOpts, client.Broker(*c.opts.Broker))
broker.DefaultBroker = *c.opts.Broker
return serverOpts, clientOpts
}
func (c *cmd) setStore(s store.Store) ([]server.Option, []client.Option) {
var serverOpts []server.Option
var clientOpts []client.Option
*c.opts.Store = s
store.DefaultStore = *c.opts.Store
return serverOpts, clientOpts
}
func (c *cmd) setTransport(t transport.Transport) ([]server.Option, []client.Option) {
var serverOpts []server.Option
var clientOpts []client.Option
*c.opts.Transport = t
serverOpts = append(serverOpts, server.Transport(*c.opts.Transport))
clientOpts = append(clientOpts, client.Transport(*c.opts.Transport))
transport.DefaultTransport = *c.opts.Transport
return serverOpts, clientOpts
}
func (c *cmd) Init(opts ...Option) error {
for _, o := range opts {
o(&c.opts)

42
cmd/options.go
View File

@ -21,22 +21,22 @@ type Options struct {
// Other options for implementations of the interface
// can be stored in a context
Context context.Context
Auth *auth.Auth
Selector *selector.Selector
Profile *profile.Profile
Context context.Context
Auth *auth.Auth
Selector *selector.Selector
DebugProfile *profile.Profile
Registry *registry.Registry
Brokers map[string]func(...broker.Option) broker.Broker
Transport *transport.Transport
Cache *cache.Cache
Config *config.Config
Client *client.Client
Server *server.Server
Caches map[string]func(...cache.Option) cache.Cache
Tracer *trace.Tracer
Profiles map[string]func(...profile.Option) profile.Profile
Brokers map[string]func(...broker.Option) broker.Broker
Transport *transport.Transport
Cache *cache.Cache
Config *config.Config
Client *client.Client
Server *server.Server
Caches map[string]func(...cache.Option) cache.Cache
Tracer *trace.Tracer
DebugProfiles map[string]func(...profile.Option) profile.Profile
// We need pointers to things so we can swap them out if needed.
Broker *broker.Broker
@ -81,72 +81,84 @@ func Version(v string) Option {
func Broker(b *broker.Broker) Option {
return func(o *Options) {
o.Broker = b
broker.DefaultBroker = *b
}
}
func Cache(c *cache.Cache) Option {
return func(o *Options) {
o.Cache = c
cache.DefaultCache = *c
}
}
func Config(c *config.Config) Option {
return func(o *Options) {
o.Config = c
config.DefaultConfig = *c
}
}
func Selector(s *selector.Selector) Option {
return func(o *Options) {
o.Selector = s
selector.DefaultSelector = *s
}
}
func Registry(r *registry.Registry) Option {
return func(o *Options) {
o.Registry = r
registry.DefaultRegistry = *r
}
}
func Transport(t *transport.Transport) Option {
return func(o *Options) {
o.Transport = t
transport.DefaultTransport = *t
}
}
func Client(c *client.Client) Option {
return func(o *Options) {
o.Client = c
client.DefaultClient = *c
}
}
func Server(s *server.Server) Option {
return func(o *Options) {
o.Server = s
server.DefaultServer = *s
}
}
func Store(s *store.Store) Option {
return func(o *Options) {
o.Store = s
store.DefaultStore = *s
}
}
func Tracer(t *trace.Tracer) Option {
return func(o *Options) {
o.Tracer = t
trace.DefaultTracer = *t
}
}
func Auth(a *auth.Auth) Option {
return func(o *Options) {
o.Auth = a
auth.DefaultAuth = *a
}
}
func Profile(p *profile.Profile) Option {
return func(o *Options) {
o.Profile = p
o.DebugProfile = p
profile.DefaultProfile = *p
}
}
@ -223,6 +235,6 @@ func NewConfig(name string, t func(...config.Option) (config.Config, error)) Opt
// New profile func.
func NewProfile(name string, t func(...profile.Option) profile.Profile) Option {
return func(o *Options) {
o.Profiles[name] = t
o.DebugProfiles[name] = t
}
}

56
config/source/nats/README.md Normal file
View File

@ -0,0 +1,56 @@
# Nats Source
The nats source reads config from nats key/values
## Nats Format
The nats source expects keys under the default bucket `default` default key `micro_config`
Values are expected to be json
```
nats kv put default micro_config '{"nats": {"address": "10.0.0.1", "port": 8488}}'
```
```
conf.Get("nats")
```
## New Source
Specify source with data
```go
natsSource := nats.NewSource(
nats.WithUrl("127.0.0.1:4222"),
nats.WithBucket("my_bucket"),
nats.WithKey("my_key"),
)
```
## Load Source
Load the source into config
```go
// Create new config
conf := config.NewConfig()
// Load nats source
conf.Load(natsSource)
```
## Watch
```go
wh, _ := natsSource.Watch()
for {
v, err := watcher.Next()
if err != nil {
log.Fatalf("err %v", err)
}
log.Infof("data %v", string(v.Data))
}
```

134
config/source/nats/nats.go Normal file
View File

@ -0,0 +1,134 @@
package nats
import (
"fmt"
"net"
"strings"
"time"
natsgo "github.com/nats-io/nats.go"
"go-micro.dev/v5/config/source"
log "go-micro.dev/v5/logger"
)
type nats struct {
url string
bucket string
key string
kv natsgo.KeyValue
opts source.Options
}
// DefaultBucket is the bucket that nats keys will be assumed to have if you
// haven't specified one.
var (
DefaultBucket = "default"
DefaultKey = "micro_config"
)
func (n *nats) Read() (*source.ChangeSet, error) {
e, err := n.kv.Get(n.key)
if err != nil {
if err == natsgo.ErrKeyNotFound {
return nil, nil
}
return nil, err
}
if e.Value() == nil || len(e.Value()) == 0 {
return nil, fmt.Errorf("source not found: %s", n.key)
}
cs := &source.ChangeSet{
Data: e.Value(),
Format: n.opts.Encoder.String(),
Source: n.String(),
Timestamp: time.Now(),
}
cs.Checksum = cs.Sum()
return cs, nil
}
func (n *nats) Write(cs *source.ChangeSet) error {
_, err := n.kv.Put(n.key, cs.Data)
if err != nil {
return err
}
return nil
}
func (n *nats) String() string {
return "nats"
}
func (n *nats) Watch() (source.Watcher, error) {
return newWatcher(n.kv, n.bucket, n.key, n.String(), n.opts.Encoder)
}
func NewSource(opts ...source.Option) source.Source {
options := source.NewOptions(opts...)
config := natsgo.GetDefaultOptions()
urls, ok := options.Context.Value(urlKey{}).([]string)
endpoints := []string{}
if ok {
for _, u := range urls {
addr, port, err := net.SplitHostPort(u)
if ae, ok := err.(*net.AddrError); ok && ae.Err == "missing port in address" {
port = "4222"
addr = u
endpoints = append(endpoints, fmt.Sprintf("%s:%s", addr, port))
} else if err == nil {
endpoints = append(endpoints, fmt.Sprintf("%s:%s", addr, port))
}
}
}
if len(endpoints) == 0 {
endpoints = append(endpoints, "127.0.0.1:4222")
}
bucket, ok := options.Context.Value(bucketKey{}).(string)
if !ok {
bucket = DefaultBucket
}
key, ok := options.Context.Value(keyKey{}).(string)
if !ok {
key = DefaultKey
}
config.Url = strings.Join(endpoints, ",")
nc, err := natsgo.Connect(config.Url)
if err != nil {
log.Error(err)
}
js, err := nc.JetStream(natsgo.MaxWait(10 * time.Second))
if err != nil {
log.Error(err)
}
kv, err := js.KeyValue(bucket)
if err == natsgo.ErrBucketNotFound || err == natsgo.ErrKeyNotFound {
kv, err = js.CreateKeyValue(&natsgo.KeyValueConfig{Bucket: bucket})
if err != nil {
log.Error(err)
}
}
if err != nil {
log.Error(err)
}
return &nats{
url: config.Url,
bucket: bucket,
key: key,
kv: kv,
opts: options,
}
}

54
config/source/nats/options.go Normal file
View File

@ -0,0 +1,54 @@
package nats
import (
"context"
"time"
natsgo "github.com/nats-io/nats.go"
"go-micro.dev/v5/config/source"
)
type (
urlKey struct{}
bucketKey struct{}
keyKey struct{}
)
// WithUrl sets the nats url.
func WithUrl(a ...string) source.Option {
return func(o *source.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, urlKey{}, a)
}
}
// WithBucket sets the nats key.
func WithBucket(a string) source.Option {
return func(o *source.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, bucketKey{}, a)
}
}
// WithKey sets the nats key.
func WithKey(a string) source.Option {
return func(o *source.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, keyKey{}, a)
}
}
func Client(url string) (natsgo.JetStreamContext, error) {
nc, err := natsgo.Connect(url)
if err != nil {
return nil, err
}
return nc.JetStream(natsgo.MaxWait(10 * time.Second))
}

79
config/source/nats/watcher.go Normal file
View File

@ -0,0 +1,79 @@
package nats
import (
"time"
natsgo "github.com/nats-io/nats.go"
"go-micro.dev/v5/config/encoder"
"go-micro.dev/v5/config/source"
)
type watcher struct {
e encoder.Encoder
name string
bucket string
key string
ch chan *source.ChangeSet
exit chan bool
}
func newWatcher(kv natsgo.KeyValue, bucket, key, name string, e encoder.Encoder) (source.Watcher, error) {
w := &watcher{
e: e,
name: name,
bucket: bucket,
key: key,
ch: make(chan *source.ChangeSet),
exit: make(chan bool),
}
wh, _ := kv.Watch(key)
go func() {
for {
select {
case v := <-wh.Updates():
if v != nil {
w.handle(v.Value())
}
case <-w.exit:
_ = wh.Stop()
return
}
}
}()
return w, nil
}
func (w *watcher) handle(data []byte) {
cs := &source.ChangeSet{
Timestamp: time.Now(),
Format: w.e.String(),
Source: w.name,
Data: data,
}
cs.Checksum = cs.Sum()
w.ch <- cs
}
func (w *watcher) Next() (*source.ChangeSet, error) {
select {
case cs := <-w.ch:
return cs, nil
case <-w.exit:
return nil, source.ErrWatcherStopped
}
}
func (w *watcher) Stop() error {
select {
case <-w.exit:
return nil
default:
close(w.exit)
}
return nil
}

33
go.mod
View File

@ -6,26 +6,36 @@ toolchain go1.24.1
require (
github.com/bitly/go-simplejson v0.5.0
github.com/cornelk/hashmap v1.0.8
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
github.com/dgrijalva/jwt-go v3.2.0+incompatible
github.com/fsnotify/fsnotify v1.6.0
github.com/go-redis/redis/v8 v8.11.5
github.com/go-sql-driver/mysql v1.9.2
github.com/golang/protobuf v1.5.4
github.com/google/uuid v1.6.0
github.com/hashicorp/consul/api v1.32.1
github.com/imdario/mergo v0.3.12
github.com/kr/pretty v0.3.0
github.com/imdario/mergo v0.3.13
github.com/jackc/pgx/v4 v4.18.3
github.com/kr/pretty v0.3.1
github.com/lib/pq v1.10.9
github.com/micro/plugins/v5/auth/jwt v0.0.0-20250502062951-be3f35ce6464
github.com/miekg/dns v1.1.50
github.com/mitchellh/hashstructure v1.1.0
github.com/nats-io/nats-server/v2 v2.11.3
github.com/nats-io/nats.go v1.42.0
github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c
github.com/patrickmn/go-cache v2.1.0+incompatible
github.com/pkg/errors v0.9.1
github.com/streadway/amqp v1.1.0
github.com/stretchr/testify v1.10.0
github.com/test-go/testify v1.1.4
github.com/urfave/cli/v2 v2.25.7
go.etcd.io/bbolt v1.4.0
go.etcd.io/etcd/api/v3 v3.5.21
go.etcd.io/etcd/client/v3 v3.5.21
go.opentelemetry.io/otel v1.35.0
go.opentelemetry.io/otel/trace v1.35.0
go.uber.org/zap v1.27.0
golang.org/x/crypto v0.37.0
golang.org/x/net v0.38.0
@ -45,7 +55,10 @@ require (
github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
github.com/fatih/color v1.16.0 // indirect
github.com/go-logr/logr v1.4.2 // indirect
github.com/go-logr/stdr v1.2.2 // indirect
github.com/gogo/protobuf v1.3.2 // indirect
github.com/google/go-tpm v0.9.3 // indirect
github.com/hashicorp/errwrap v1.1.0 // indirect
github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
github.com/hashicorp/go-hclog v1.5.0 // indirect
@ -54,27 +67,39 @@ require (
github.com/hashicorp/go-rootcerts v1.0.2 // indirect
github.com/hashicorp/golang-lru v0.5.4 // indirect
github.com/hashicorp/serf v0.10.1 // indirect
github.com/jackc/chunkreader/v2 v2.0.1 // indirect
github.com/jackc/pgconn v1.14.3 // indirect
github.com/jackc/pgio v1.0.0 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgproto3/v2 v2.3.3 // indirect
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
github.com/jackc/pgtype v1.14.0 // indirect
github.com/jackc/puddle v1.3.0 // indirect
github.com/klauspost/compress v1.18.0 // indirect
github.com/kr/text v0.2.0 // indirect
github.com/mattn/go-colorable v0.1.13 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/minio/highwayhash v1.0.3 // indirect
github.com/mitchellh/go-homedir v1.1.0 // indirect
github.com/mitchellh/mapstructure v1.5.0 // indirect
github.com/nats-io/jwt/v2 v2.7.4 // indirect
github.com/nats-io/nkeys v0.4.11 // indirect
github.com/nats-io/nuid v1.0.1 // indirect
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
github.com/rogpeppe/go-internal v1.12.0 // indirect
github.com/rogpeppe/go-internal v1.13.1 // indirect
github.com/russross/blackfriday/v2 v2.1.0 // indirect
github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
go.etcd.io/etcd/client/pkg/v3 v3.5.21 // indirect
go.opentelemetry.io/auto/sdk v1.1.0 // indirect
go.opentelemetry.io/otel/metric v1.35.0 // indirect
go.uber.org/multierr v1.10.0 // indirect
golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 // indirect
golang.org/x/mod v0.24.0 // indirect
golang.org/x/sys v0.32.0 // indirect
golang.org/x/text v0.24.0 // indirect
golang.org/x/time v0.11.0 // indirect
golang.org/x/tools v0.31.0 // indirect
google.golang.org/genproto/googleapis/api v0.0.0-20250324211829-b45e905df463 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20250324211829-b45e905df463 // indirect
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)

170
go.sum
View File

@ -1,10 +1,14 @@
filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
github.com/Masterminds/semver/v3 v3.1.1/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs=
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/antithesishq/antithesis-sdk-go v0.4.3-default-no-op h1:+OSa/t11TFhqfrX0EOSqQBDJ0YlpmK0rDSiB19dg9M0=
github.com/antithesishq/antithesis-sdk-go v0.4.3-default-no-op/go.mod h1:IUpT2DPAKh6i/YhSbt6Gl3v2yvUZjmKncl7U91fup7E=
github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
github.com/armon/go-metrics v0.4.1 h1:hR91U9KYmb6bLBYLQjyM+3j+rcd/UhE+G78SFnF8gJA=
@ -24,17 +28,26 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UF
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
github.com/cockroachdb/apd v1.1.0 h1:3LFP3629v+1aKXU5Q37mxmRxX/pIu1nijXydLShEq5I=
github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ=
github.com/coreos/go-semver v0.3.0 h1:wkHLiw0WNATZnSG7epLsujiMCgPAc9xhjJ4tgnAxmfM=
github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
github.com/coreos/go-systemd v0.0.0-20190719114852-fd7a80b32e1f/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
github.com/coreos/go-systemd/v22 v22.3.2 h1:D9/bQk5vlXQFZ6Kwuu6zaiXJ9oTPe68++AzAJc1DzSI=
github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/cornelk/hashmap v1.0.8 h1:nv0AWgw02n+iDcawr5It4CjQIAcdMMKRrs10HOJYlrc=
github.com/cornelk/hashmap v1.0.8/go.mod h1:RfZb7JO3RviW/rT6emczVuC/oxpdz4UsSB2LJSclR1k=
github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
@ -46,8 +59,11 @@ github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4
github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
@ -58,6 +74,8 @@ github.com/go-sql-driver/mysql v1.9.2 h1:4cNKDYQ1I84SXslGddlsrMhc8k4LeDVj6Ad6WRj
github.com/go-sql-driver/mysql v1.9.2/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU=
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/gofrs/uuid v4.0.0+incompatible h1:1SD/1F5pU8p29ybwgQSwpQk+mwdRrXCYuPhW6m+TnJw=
github.com/gofrs/uuid v4.0.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
@ -71,9 +89,12 @@ github.com/google/btree v1.0.1 h1:gK4Kx5IaGY9CD5sPJ36FHiBJ6ZXl0kilRiiCj+jdYp4=
github.com/google/btree v1.0.1/go.mod h1:xXMiIv4Fb/0kKde4SpL7qlzvu5cMJDRkFDxJfI9uaxA=
github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/go-tpm v0.9.3 h1:+yx0/anQuGzi+ssRqeD6WpXjW2L/V0dItUayO0i9sRc=
github.com/google/go-tpm v0.9.3/go.mod h1:h9jEsEECg7gtLis0upRBQU+GhYVH6jMjrFxI8u6bVUY=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/hashicorp/consul/api v1.32.1 h1:0+osr/3t/aZNAdJX558crU3PEjVrG4x6715aZHRgceE=
@ -120,8 +141,57 @@ github.com/hashicorp/memberlist v0.5.0 h1:EtYPN8DpAURiapus508I4n9CzHs2W+8NZGbmmR
github.com/hashicorp/memberlist v0.5.0/go.mod h1:yvyXLpo0QaGE59Y7hDTsTzDD25JYBZ4mHgHUZ8lrOI0=
github.com/hashicorp/serf v0.10.1 h1:Z1H2J60yRKvfDYAOZLd2MU0ND4AH/WDz7xYHDWQsIPY=
github.com/hashicorp/serf v0.10.1/go.mod h1:yL2t6BqATOLGc5HF7qbFkTfXoPIY0WZdWHfEvMqbG+4=
github.com/imdario/mergo v0.3.12 h1:b6R2BslTbIEToALKP7LxUvijTsNI9TAe80pLWN2g/HU=
github.com/imdario/mergo v0.3.12/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
github.com/imdario/mergo v0.3.13 h1:lFzP57bqS/wsqKssCGmtLAb8A0wKjLGrve2q3PPVcBk=
github.com/imdario/mergo v0.3.13/go.mod h1:4lJ1jqUDcsbIECGy0RUJAXNIhg+6ocWgb1ALK2O4oXg=
github.com/jackc/chunkreader v1.0.0/go.mod h1:RT6O25fNZIuasFJRyZ4R/Y2BbhasbmZXF9QQ7T3kePo=
github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk=
github.com/jackc/chunkreader/v2 v2.0.1 h1:i+RDz65UE+mmpjTfyz0MoVTnzeYxroil2G82ki7MGG8=
github.com/jackc/chunkreader/v2 v2.0.1/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk=
github.com/jackc/pgconn v0.0.0-20190420214824-7e0022ef6ba3/go.mod h1:jkELnwuX+w9qN5YIfX0fl88Ehu4XC3keFuOJJk9pcnA=
github.com/jackc/pgconn v0.0.0-20190824142844-760dd75542eb/go.mod h1:lLjNuW/+OfW9/pnVKPazfWOgNfH2aPem8YQ7ilXGvJE=
github.com/jackc/pgconn v0.0.0-20190831204454-2fabfa3c18b7/go.mod h1:ZJKsE/KZfsUgOEh9hBm+xYTstcNHg7UPMVJqRfQxq4s=
github.com/jackc/pgconn v1.8.0/go.mod h1:1C2Pb36bGIP9QHGBYCjnyhqu7Rv3sGshaQUvmfGIB/o=
github.com/jackc/pgconn v1.9.0/go.mod h1:YctiPyvzfU11JFxoXokUOOKQXQmDMoJL9vJzHH8/2JY=
github.com/jackc/pgconn v1.9.1-0.20210724152538-d89c8390a530/go.mod h1:4z2w8XhRbP1hYxkpTuBjTS3ne3J48K83+u0zoyvg2pI=
github.com/jackc/pgconn v1.14.3 h1:bVoTr12EGANZz66nZPkMInAV/KHD2TxH9npjXXgiB3w=
github.com/jackc/pgconn v1.14.3/go.mod h1:RZbme4uasqzybK2RK5c65VsHxoyaml09lx3tXOcO/VM=
github.com/jackc/pgio v1.0.0 h1:g12B9UwVnzGhueNavwioyEEpAmqMe1E/BN9ES+8ovkE=
github.com/jackc/pgio v1.0.0/go.mod h1:oP+2QK2wFfUWgr+gxjoBH9KGBb31Eio69xUb0w5bYf8=
github.com/jackc/pgmock v0.0.0-20190831213851-13a1b77aafa2/go.mod h1:fGZlG77KXmcq05nJLRkk0+p82V8B8Dw8KN2/V9c/OAE=
github.com/jackc/pgmock v0.0.0-20201204152224-4fe30f7445fd/go.mod h1:hrBW0Enj2AZTNpt/7Y5rr2xe/9Mn757Wtb2xeBzPv2c=
github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65 h1:DadwsjnMwFjfWc9y5Wi/+Zz7xoE5ALHsRQlOctkOiHc=
github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65/go.mod h1:5R2h2EEX+qri8jOWMbJCtaPWkrrNc7OHwsp2TCqp7ak=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgproto3 v1.1.0/go.mod h1:eR5FA3leWg7p9aeAqi37XOTgTIbkABlvcPB3E5rlc78=
github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190420180111-c116219b62db/go.mod h1:bhq50y+xrl9n5mRYyCBFKkpRVTLYJVWeCc+mEAI3yXA=
github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190609003834-432c2951c711/go.mod h1:uH0AWtUmuShn0bcesswc4aBTWGvw0cAxIJp+6OB//Wg=
github.com/jackc/pgproto3/v2 v2.0.0-rc3/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvWKnT95C46ckYeM=
github.com/jackc/pgproto3/v2 v2.0.0-rc3.0.20190831210041-4c03ce451f29/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvWKnT95C46ckYeM=
github.com/jackc/pgproto3/v2 v2.0.6/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
github.com/jackc/pgproto3/v2 v2.1.1/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
github.com/jackc/pgproto3/v2 v2.3.3 h1:1HLSx5H+tXR9pW3in3zaztoEwQYRC9SQaYUHjTSUOag=
github.com/jackc/pgproto3/v2 v2.3.3/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b/go.mod h1:vsD4gTJCa9TptPL8sPkXrLZ+hDuNrZCnj29CQpr4X1E=
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgtype v0.0.0-20190421001408-4ed0de4755e0/go.mod h1:hdSHsc1V01CGwFsrv11mJRHWJ6aifDLfdV3aVjFF0zg=
github.com/jackc/pgtype v0.0.0-20190824184912-ab885b375b90/go.mod h1:KcahbBH1nCMSo2DXpzsoWOAfFkdEtEJpPbVLq8eE+mc=
github.com/jackc/pgtype v0.0.0-20190828014616-a8802b16cc59/go.mod h1:MWlu30kVJrUS8lot6TQqcg7mtthZ9T0EoIBFiJcmcyw=
github.com/jackc/pgtype v1.8.1-0.20210724151600-32e20a603178/go.mod h1:C516IlIV9NKqfsMCXTdChteoXmwgUceqaLfjg2e3NlM=
github.com/jackc/pgtype v1.14.0 h1:y+xUdabmyMkJLyApYuPj38mW+aAIqCe5uuBB51rH3Vw=
github.com/jackc/pgtype v1.14.0/go.mod h1:LUMuVrfsFfdKGLw+AFFVv6KtHOFMwRgDDzBt76IqCA4=
github.com/jackc/pgx/v4 v4.0.0-20190420224344-cc3461e65d96/go.mod h1:mdxmSJJuR08CZQyj1PVQBHy9XOp5p8/SHH6a0psbY9Y=
github.com/jackc/pgx/v4 v4.0.0-20190421002000-1b8f0016e912/go.mod h1:no/Y67Jkk/9WuGR0JG/JseM9irFbnEPbuWV2EELPNuM=
github.com/jackc/pgx/v4 v4.0.0-pre1.0.20190824185557-6972a5742186/go.mod h1:X+GQnOEnf1dqHGpw7JmHqHc1NxDoalibchSk9/RWuDc=
github.com/jackc/pgx/v4 v4.12.1-0.20210724153913-640aa07df17c/go.mod h1:1QD0+tgSXP7iUjYm9C1NxKhny7lq6ee99u/z+IHFcgs=
github.com/jackc/pgx/v4 v4.18.3 h1:dE2/TrEsGX3RBprb3qryqSV9Y60iZN1C6i8IrmW9/BA=
github.com/jackc/pgx/v4 v4.18.3/go.mod h1:Ey4Oru5tH5sB6tV7hDmfWFahwF15Eb7DNXlRKx2CkVw=
github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
github.com/jackc/puddle v1.1.3/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
github.com/jackc/puddle v1.3.0 h1:eHK/5clGOatcjX3oWGBO/MpxpbHzSwud5EWTSCI+MX0=
github.com/jackc/puddle v1.3.0/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
@ -130,16 +200,24 @@ github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+o
github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
github.com/lib/pq v1.1.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
github.com/lib/pq v1.10.2/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
@ -147,6 +225,8 @@ github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb
github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
@ -155,10 +235,14 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
github.com/micro/plugins/v5/auth/jwt v0.0.0-20250502062951-be3f35ce6464 h1:einNYloNFQ4h52c0CBvWv67frSq1xS0EUXCf1ncr1UM=
github.com/micro/plugins/v5/auth/jwt v0.0.0-20250502062951-be3f35ce6464/go.mod h1:Mqqsr1LYrIiAuqKUI/C0sJRoIB80SATNBagcXjqK7oQ=
github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKjuso=
github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI=
github.com/miekg/dns v1.1.50 h1:DQUfb9uc6smULcREF09Uc+/Gd46YWqJd5DbpPE9xkcA=
github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7XnME=
github.com/minio/highwayhash v1.0.3 h1:kbnuUMoHYyVl7szWjSxJnxw11k2U709jqFPPmIUyD6Q=
github.com/minio/highwayhash v1.0.3/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI=
github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
@ -172,6 +256,10 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJ
github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
github.com/nats-io/jwt/v2 v2.7.4 h1:jXFuDDxs/GQjGDZGhNgH4tXzSUK6WQi2rsj4xmsNOtI=
github.com/nats-io/jwt/v2 v2.7.4/go.mod h1:me11pOkwObtcBNR8AiMrUbtVOUGkqYjMQZ6jnSdVUIA=
github.com/nats-io/nats-server/v2 v2.11.3 h1:AbGtXxuwjo0gBroLGGr/dE0vf24kTKdRnBq/3z/Fdoc=
github.com/nats-io/nats-server/v2 v2.11.3/go.mod h1:6Z6Fd+JgckqzKig7DYwhgrE7bJ6fypPHnGPND+DqgMY=
github.com/nats-io/nats.go v1.42.0 h1:ynIMupIOvf/ZWH/b2qda6WGKGNSjwOUutTpWRvAmhaM=
github.com/nats-io/nats.go v1.42.0/go.mod h1:iRWIPokVIFbVijxuMQq4y9ttaBTMe0SFdlZfMDd+33g=
github.com/nats-io/nkeys v0.4.11 h1:q44qGV008kYd9W1b1nEBkNzvnWxtRSQ7A8BoqRrcfa0=
@ -191,6 +279,7 @@ github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0Mw
github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@ -211,26 +300,42 @@ github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8b
github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
github.com/rs/zerolog v1.13.0/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU=
github.com/rs/zerolog v1.15.0/go.mod h1:xYTKnLHcpfU2225ny5qZjxnj9NvkumZYjJHlAThCjNc=
github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 h1:nn5Wsu0esKSJiIVhscUtVbo7ada43DJhG55ua/hjS5I=
github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
github.com/shopspring/decimal v0.0.0-20180709203117-cd690d0c9e24/go.mod h1:M+9NzErvs504Cn4c5DxATwIqPbtswREoFCre64PpcG4=
github.com/shopspring/decimal v1.2.0 h1:abSATXmQEYyShuxI4/vyW3tV1MrKAJzCZ/0zLUXYbsQ=
github.com/shopspring/decimal v1.2.0/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o=
github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
github.com/streadway/amqp v1.1.0 h1:py12iX8XSyI7aN/3dUT8DFIDJazNJsVJdxNVEpnQTZM=
github.com/streadway/amqp v1.1.0/go.mod h1:WYSrTEYHOXHd0nwFeUXAe2G2hRnQT+deZJJf88uS9Bg=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/test-go/testify v1.1.4 h1:Tf9lntrKUMHiXQ07qBScBTSA0dhYQlu83hswqelv1iE=
github.com/test-go/testify v1.1.4/go.mod h1:rH7cfJo/47vWGdi4GPj16x3/t1xGOj2YxzmNQzk2ghU=
github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs=
github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
@ -239,6 +344,7 @@ github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsr
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q=
go.etcd.io/bbolt v1.4.0 h1:TU77id3TnN/zKr7CO/uk+fBCwF2jGcMuw2B/FMAzYIk=
go.etcd.io/bbolt v1.4.0/go.mod h1:AsD+OCi/qPN1giOX1aiLAha3o1U8rAz65bvN4j0sRuk=
go.etcd.io/etcd/api/v3 v3.5.21 h1:A6O2/JDb3tvHhiIz3xf9nJ7REHvtEFJJ3veW3FbCnS8=
@ -259,30 +365,52 @@ go.opentelemetry.io/otel/sdk/metric v1.35.0 h1:1RriWBmCKgkeHEhM7a2uMjMUfP7MsOF5J
go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w=
go.opentelemetry.io/otel/trace v1.35.0 h1:dPpEfJu1sDIqruz7BHFG3c7528f6ddfSWfFDVt/xgMs=
go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc=
go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20190411191339-88737f569e3a/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20201203163018-be400aefbc4c/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 h1:nDVHiLt8aIbd/VzvPWN6kSOPE7+F/fNFDSXLVYkE/Iw=
golang.org/x/exp v0.0.0-20250305212735-054e65f0b394/go.mod h1:sIifuuw/Yco/y6yb6+bDNfyeQ/MdPUy/hKEMYQV17cM=
golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=
golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
@ -305,8 +433,10 @@ golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5h
golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@ -319,6 +449,7 @@ golang.org/x/sys v0.0.0-20210303074136-134d130e1a04/go.mod h1:h1NjWce9XRLGQEsW7w
golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@ -326,23 +457,37 @@ golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBc
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0=
golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190425163242-31fd60d6bfdc/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190823170909-c4a336ef6a2f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.31.0 h1:0EedkvKDbh+qistFTd0Bcwe/YLh4vHwWEkiI0toFIBU=
golang.org/x/tools v0.31.0/go.mod h1:naFTU+Cev749tSJRXJlna0T3WxKvb1kWEx15xA4SdmQ=
golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@ -364,14 +509,17 @@ gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
gopkg.in/inconshreveable/log15.v2 v2.0.0-20180818164646-67afb5ed74ec/go.mod h1:aPpfJ7XW+gOuirDoZ8gHhLh3kZ1B08FtV2bbmy7Jv3s=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=

46
profile/profile.go
View File

@ -3,15 +3,18 @@ package profile
import (
"os"
"strings"
natslib "github.com/nats-io/nats.go"
"go-micro.dev/v5/broker"
"go-micro.dev/v5/broker/http"
"go-micro.dev/v5/broker/nats"
"go-micro.dev/v5/registry"
nreg "go-micro.dev/v5/registry/nats"
"go-micro.dev/v5/store"
nstore "go-micro.dev/v5/store/nats-js-kv"
"go-micro.dev/v5/transport"
ntx "go-micro.dev/v5/transport/nats"
)
type Profile struct {
@ -21,23 +24,52 @@ type Profile struct {
Transport transport.Transport
}
// LocalProfile returns a profile with local mDNS as the registry, HTTP as the broker, file as the store, and HTTP as the transport
// It is used for local development and testing
func LocalProfile() Profile {
return Profile{
Registry: registry.NewMDNSRegistry(),
Broker: http.NewHttpBroker(),
Broker: broker.NewHttpBroker(),
Store: store.NewFileStore(),
Transport: transport.NewHTTPTransport(),
}
}
// NatsProfile returns a profile with NATS as the registry, broker, store, and transport
// It uses the environment variable MICR_NATS_ADDRESS to set the NATS server address
// If the variable is not set, it defaults to nats://0.0.0.0:4222 which will connect to a local NATS server
func NatsProfile() Profile {
addr := os.Getenv("MICRO_NATS_ADDRESS")
if addr == "" {
addr = "nats://0.0.0.0:4222"
}
// Split the address by comma, trim whitespace, and convert to a slice of strings
addrs := splitNatsAdressList(addr)
reg := nreg.NewNatsRegistry(registry.Addrs(addrs...))
brok := nats.NewNatsBroker(broker.Addrs(addrs...))
st := nstore.NewStore(nstore.NatsOptions(natslib.Options{Servers: addrs}))
tx := ntx.NewTransport(ntx.Options(natslib.Options{Servers: addrs}))
registry.DefaultRegistry = reg
broker.DefaultBroker = brok
store.DefaultStore = st
transport.DefaultTransport = tx
return Profile{
Registry: nreg.NewNatsRegistry(registry.Addrs(addr)),
Broker: nats.NewNatsBroker(broker.Addrs(addr)),
Store: store.NewFileStore(), // nats-backed store when available
Transport: transport.NewHTTPTransport(), // nats transport when available
Registry: reg,
Broker: brok,
Store: st,
Transport: tx,
}
}
func splitNatsAdressList(addr string) []string {
// Split the address by comma
addrs := strings.Split(addr, ",")
// Trim any whitespace from each address
for i, a := range addrs {
addrs[i] = strings.TrimSpace(a)
}
return addrs
}
// Add more profiles as needed, e.g. grpc

13
service/options.go
View File

@ -83,12 +83,14 @@ func Broker(b broker.Broker) Option {
// Update Client and Server
o.Client.Init(client.Broker(b))
o.Server.Init(server.Broker(b))
broker.DefaultBroker = b
}
}
func Cache(c cache.Cache) Option {
return func(o *Options) {
o.Cache = c
cache.DefaultCache = c
}
}
@ -102,6 +104,7 @@ func Cmd(c cmd.Cmd) Option {
func Client(c client.Client) Option {
return func(o *Options) {
o.Client = c
client.DefaultClient = c
}
}
@ -135,6 +138,7 @@ func HandleSignal(b bool) Option {
func Profile(p profile.Profile) Option {
return func(o *Options) {
o.Profile = p
profile.DefaultProfile = p
}
}
@ -142,6 +146,7 @@ func Profile(p profile.Profile) Option {
func Server(s server.Server) Option {
return func(o *Options) {
o.Server = s
server.DefaultServer = s
}
}
@ -149,6 +154,7 @@ func Server(s server.Server) Option {
func Store(s store.Store) Option {
return func(o *Options) {
o.Store = s
store.DefaultStore = s
}
}
@ -162,6 +168,7 @@ func Registry(r registry.Registry) Option {
o.Server.Init(server.Registry(r))
// Update Broker
o.Broker.Init(broker.Registry(r))
broker.DefaultBroker = o.Broker
}
}
@ -170,12 +177,15 @@ func Tracer(t trace.Tracer) Option {
return func(o *Options) {
o.Server.Init(server.Tracer(t))
}
}
// Auth sets the auth for the service.
func Auth(a auth.Auth) Option {
return func(o *Options) {
o.Auth = a
auth.DefaultAuth = a
}
}
@ -183,6 +193,7 @@ func Auth(a auth.Auth) Option {
func Config(c config.Config) Option {
return func(o *Options) {
o.Config = c
config.DefaultConfig = c
}
}
@ -190,6 +201,7 @@ func Config(c config.Config) Option {
func Selector(s selector.Selector) Option {
return func(o *Options) {
o.Client.Init(client.Selector(s))
selector.DefaultSelector = s
}
}
@ -201,6 +213,7 @@ func Transport(t transport.Transport) Option {
// Update Client and Server
o.Client.Init(client.Transport(t))
o.Server.Init(server.Transport(t))
transport.DefaultTransport = t
}
}

79
store/nats-js-kv/README.md Normal file
View File

@ -0,0 +1,79 @@
# NATS JetStream Key Value Store Plugin
This plugin uses the NATS JetStream [KeyValue Store](https://docs.nats.io/nats-concepts/jetstream/key-value-store) to implement the Go-Micro store interface.
You can use this plugin like any other store plugin.
To start a local NATS JetStream server run `nats-server -js`.
To manually create a new storage object call:
```go
natsjskv.NewStore(opts ...store.Option)
```
The Go-Micro store interface uses databases and tables to store keys. These translate
to buckets (key value stores) and key prefixes. If no database (bucket name) is provided, "default" will be used.
You can call `Write` with any arbitrary database name, and if a bucket with that name does not exist yet,
it will be automatically created.
If a table name is provided, it will use it to prefix the key as `<table>_<key>`.
To delete a bucket, and all the key/value pairs in it, pass the `DeleteBucket` option to the `Delete`
method, then they key name will be interpreted as a bucket name, and the bucket will be deleted.
Next to the default store options, a few NATS specific options are available:
```go
// NatsOptions accepts nats.Options
NatsOptions(opts nats.Options)
// JetStreamOptions accepts multiple nats.JSOpt
JetStreamOptions(opts ...nats.JSOpt)
// KeyValueOptions accepts multiple nats.KeyValueConfig
// This will create buckets with the provided configs at initialization.
//
// type KeyValueConfig struct {
// Bucket string
// Description string
// MaxValueSize int32
// History uint8
// TTL time.Duration
// MaxBytes int64
// Storage StorageType
// Replicas int
// Placement *Placement
// RePublish *RePublish
// Mirror *StreamSource
// Sources []*StreamSource
}
KeyValueOptions(cfg ...*nats.KeyValueConfig)
// DefaultTTL sets the default TTL to use for new buckets
// By default no TTL is set.
//
// TTL ON INDIVIDUAL WRITE CALLS IS NOT SUPPORTED, only bucket wide TTL.
// Either set a default TTL with this option or provide bucket specific options
// with ObjectStoreOptions
DefaultTTL(ttl time.Duration)
// DefaultMemory sets the default storage type to memory only.
//
// The default is file storage, persisting storage between service restarts.
// Be aware that the default storage location of NATS the /tmp dir is, and thus
// won't persist reboots.
DefaultMemory()
// DefaultDescription sets the default description to use when creating new
// buckets. The default is "Store managed by go-micro"
DefaultDescription(text string)
// DeleteBucket will use the key passed to Delete as a bucket (database) name,
// and delete the bucket.
// This option should not be combined with the store.DeleteFrom option, as
// that will overwrite the delete action.
DeleteBucket()
```

18
store/nats-js-kv/context.go Normal file
View File

@ -0,0 +1,18 @@
package natsjskv
import (
"context"
"go-micro.dev/v5/store"
)
// setStoreOption returns a function to setup a context with given value.
func setStoreOption(k, v interface{}) store.Option {
return func(o *store.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, k, v)
}
}

184
store/nats-js-kv/helpers_test.go Normal file
View File

@ -0,0 +1,184 @@
package natsjskv
import (
"context"
"fmt"
"net"
"os"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
nserver "github.com/nats-io/nats-server/v2/server"
"github.com/pkg/errors"
"github.com/test-go/testify/require"
"go-micro.dev/v5/store"
)
func testSetup(ctx context.Context, t *testing.T, opts ...store.Option) store.Store {
t.Helper()
var err error
var s store.Store
for i := 0; i < 5; i++ {
nCtx, cancel := context.WithCancel(ctx)
addr := startNatsServer(nCtx, t)
opts = append(opts, store.Nodes(addr), EncodeKeys())
s = NewStore(opts...)
err = s.Init()
if err != nil {
t.Log(errors.Wrap(err, "Error: Server initialization failed, restarting server"))
cancel()
if err = s.Close(); err != nil {
t.Logf("Failed to close store: %v", err)
}
time.Sleep(time.Second)
continue
}
go func() {
<-ctx.Done()
cancel()
if err = s.Close(); err != nil {
t.Logf("Failed to close store: %v", err)
}
}()
return s
}
t.Error(errors.Wrap(err, "Store initialization failed"))
return s
}
func startNatsServer(ctx context.Context, t *testing.T) string {
t.Helper()
natsAddr := getFreeLocalhostAddress()
natsPort, err := strconv.Atoi(strings.Split(natsAddr, ":")[1])
if err != nil {
t.Logf("Failed to parse port from address: %v", err)
}
clusterName := "gomicro-store-test-cluster"
// start the NATS with JetStream server
go natsServer(ctx,
t,
&nserver.Options{
Host: strings.Split(natsAddr, ":")[0],
Port: natsPort,
Cluster: nserver.ClusterOpts{
Name: clusterName,
},
},
)
time.Sleep(2 * time.Second)
return natsAddr
}
func getFreeLocalhostAddress() string {
l, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return ""
}
addr := l.Addr().String()
if err := l.Close(); err != nil {
return addr
}
return addr
}
func natsServer(ctx context.Context, t *testing.T, opts *nserver.Options) {
t.Helper()
opts.TLSTimeout = 180
server, err := nserver.NewServer(
opts,
)
require.NoError(t, err)
if err != nil {
return
}
defer server.Shutdown()
server.SetLoggerV2(
NewLogWrapper(),
false, false, false,
)
tmpdir := t.TempDir()
natsdir := filepath.Join(tmpdir, "nats-js")
jsConf := &nserver.JetStreamConfig{
StoreDir: natsdir,
}
// first start NATS
go server.Start()
time.Sleep(time.Second)
// second start JetStream
err = server.EnableJetStream(jsConf)
require.NoError(t, err)
if err != nil {
return
}
// This fixes some issues where tests fail because directory cleanup fails
t.Cleanup(func() {
contents, err := filepath.Glob(natsdir + "/*")
if err != nil {
t.Logf("Failed to glob directory: %v", err)
}
for _, item := range contents {
if err := os.RemoveAll(item); err != nil {
t.Logf("Failed to remove file: %v", err)
}
}
if err := os.RemoveAll(natsdir); err != nil {
t.Logf("Failed to remove directory: %v", err)
}
})
<-ctx.Done()
}
func NewLogWrapper() *LogWrapper {
return &LogWrapper{}
}
type LogWrapper struct {
}
// Noticef logs a notice statement.
func (l *LogWrapper) Noticef(_ string, _ ...interface{}) {
}
// Warnf logs a warning statement.
func (l *LogWrapper) Warnf(format string, v ...interface{}) {
fmt.Printf(format+"\n", v...)
}
// Fatalf logs a fatal statement.
func (l *LogWrapper) Fatalf(format string, v ...interface{}) {
fmt.Printf(format+"\n", v...)
}
// Errorf logs an error statement.
func (l *LogWrapper) Errorf(format string, v ...interface{}) {
fmt.Printf(format+"\n", v...)
}
// Debugf logs a debug statement.
func (l *LogWrapper) Debugf(_ string, _ ...interface{}) {
}
// Tracef logs a trace statement.
func (l *LogWrapper) Tracef(format string, v ...interface{}) {
fmt.Printf(format+"\n", v...)
}

119
store/nats-js-kv/keys.go Normal file
View File

@ -0,0 +1,119 @@
package natsjskv
import (
"encoding/base32"
"strings"
)
// NatsKey is a convenience function to create a key for the nats kv store.
func (n *natsStore) NatsKey(table, microkey string) string {
return n.NewKey(table, microkey, "").NatsKey()
}
// MicroKey is a convenience function to create a key for the micro interface.
func (n *natsStore) MicroKey(table, natskey string) string {
return n.NewKey(table, "", natskey).MicroKey()
}
// MicroKeyFilter is a convenience function to create a key for the micro interface.
// It returns false if the key does not match the table, prefix or suffix.
func (n *natsStore) MicroKeyFilter(table, natskey string, prefix, suffix string) (string, bool) {
k := n.NewKey(table, "", natskey)
return k.MicroKey(), k.Check(table, prefix, suffix)
}
// Key represents a key in the store.
// They are used to convert nats keys (base32 encoded) to micro keys (plain text - no table prefix) and vice versa.
type Key struct {
// Plain is the plain key as requested by the go-micro interface.
Plain string
// Full is the full key including the table prefix.
Full string
// Encoded is the base64 encoded key as used by the nats kv store.
Encoded string
}
// NewKey creates a new key. Either plain or encoded must be set.
func (n *natsStore) NewKey(table string, plain, encoded string) *Key {
k := &Key{
Plain: plain,
Encoded: encoded,
}
switch {
case k.Plain != "":
k.Full = getKey(k.Plain, table)
k.Encoded = encode(k.Full, n.encoding)
case k.Encoded != "":
k.Full = decode(k.Encoded, n.encoding)
k.Plain = trimKey(k.Full, table)
}
return k
}
// NatsKey returns a key the nats kv store can work with.
func (k *Key) NatsKey() string {
return k.Encoded
}
// MicroKey returns a key the micro interface can work with.
func (k *Key) MicroKey() string {
return k.Plain
}
// Check returns false if the key does not match the table, prefix or suffix.
func (k *Key) Check(table, prefix, suffix string) bool {
if table != "" && k.Full != getKey(k.Plain, table) {
return false
}
if prefix != "" && !strings.HasPrefix(k.Plain, prefix) {
return false
}
if suffix != "" && !strings.HasSuffix(k.Plain, suffix) {
return false
}
return true
}
func encode(s string, alg string) string {
switch alg {
case "base32":
return base32.StdEncoding.EncodeToString([]byte(s))
default:
return s
}
}
func decode(s string, alg string) string {
switch alg {
case "base32":
b, err := base32.StdEncoding.DecodeString(s)
if err != nil {
return s
}
return string(b)
default:
return s
}
}
func getKey(key, table string) string {
if table != "" {
return table + "_" + key
}
return key
}
func trimKey(key, table string) string {
if table != "" {
return strings.TrimPrefix(key, table+"_")
}
return key
}

478
store/nats-js-kv/nats.go Normal file
View File

@ -0,0 +1,478 @@
// Package natsjskv is a go-micro store plugin for NATS JetStream Key-Value store.
package natsjskv
import (
"context"
"encoding/json"
"sync"
"time"
"github.com/cornelk/hashmap"
"github.com/nats-io/nats.go"
"github.com/pkg/errors"
"go-micro.dev/v5/store"
)
var (
// ErrBucketNotFound is returned when the requested bucket does not exist.
ErrBucketNotFound = errors.New("Bucket (database) not found")
)
// KeyValueEnvelope is the data structure stored in the key value store.
type KeyValueEnvelope struct {
Key string `json:"key"`
Data []byte `json:"data"`
Metadata map[string]interface{} `json:"metadata"`
}
type natsStore struct {
sync.Once
sync.RWMutex
encoding string
ttl time.Duration
storageType nats.StorageType
description string
opts store.Options
nopts nats.Options
jsopts []nats.JSOpt
kvConfigs []*nats.KeyValueConfig
conn *nats.Conn
js nats.JetStreamContext
buckets *hashmap.Map[string, nats.KeyValue]
}
// NewStore will create a new NATS JetStream Object Store.
func NewStore(opts ...store.Option) store.Store {
options := store.Options{
Nodes: []string{},
Database: "default",
Table: "",
Context: context.Background(),
}
n := &natsStore{
description: "KeyValue storage administered by go-micro store plugin",
opts: options,
jsopts: []nats.JSOpt{},
kvConfigs: []*nats.KeyValueConfig{},
buckets: hashmap.New[string, nats.KeyValue](),
storageType: nats.FileStorage,
}
n.setOption(opts...)
return n
}
// Init initializes the store. It must perform any required setup on the
// backing storage implementation and check that it is ready for use,
// returning any errors.
func (n *natsStore) Init(opts ...store.Option) error {
n.setOption(opts...)
// Connect to NATS servers
conn, err := n.nopts.Connect()
if err != nil {
return errors.Wrap(err, "Failed to connect to NATS Server")
}
// Create JetStream context
js, err := conn.JetStream(n.jsopts...)
if err != nil {
return errors.Wrap(err, "Failed to create JetStream context")
}
n.conn = conn
n.js = js
// Create default config if no configs present
if len(n.kvConfigs) == 0 {
if _, err := n.mustGetBucketByName(n.opts.Database); err != nil {
return err
}
}
// Create kv store buckets
for _, cfg := range n.kvConfigs {
if _, err := n.mustGetBucket(cfg); err != nil {
return err
}
}
return nil
}
func (n *natsStore) setOption(opts ...store.Option) {
for _, o := range opts {
o(&n.opts)
}
n.Once.Do(func() {
n.nopts = nats.GetDefaultOptions()
})
// Extract options from context
if nopts, ok := n.opts.Context.Value(natsOptionsKey{}).(nats.Options); ok {
n.nopts = nopts
}
if jsopts, ok := n.opts.Context.Value(jsOptionsKey{}).([]nats.JSOpt); ok {
n.jsopts = append(n.jsopts, jsopts...)
}
if cfg, ok := n.opts.Context.Value(kvOptionsKey{}).([]*nats.KeyValueConfig); ok {
n.kvConfigs = append(n.kvConfigs, cfg...)
}
if ttl, ok := n.opts.Context.Value(ttlOptionsKey{}).(time.Duration); ok {
n.ttl = ttl
}
if sType, ok := n.opts.Context.Value(memoryOptionsKey{}).(nats.StorageType); ok {
n.storageType = sType
}
if text, ok := n.opts.Context.Value(descriptionOptionsKey{}).(string); ok {
n.description = text
}
if encoding, ok := n.opts.Context.Value(keyEncodeOptionsKey{}).(string); ok {
n.encoding = encoding
}
// Assign store option server addresses to nats options
if len(n.opts.Nodes) > 0 {
n.nopts.Url = ""
n.nopts.Servers = n.opts.Nodes
}
if len(n.nopts.Servers) == 0 && n.nopts.Url == "" {
n.nopts.Url = nats.DefaultURL
}
}
// Options allows you to view the current options.
func (n *natsStore) Options() store.Options {
return n.opts
}
// Read takes a single key name and optional ReadOptions. It returns matching []*Record or an error.
func (n *natsStore) Read(key string, opts ...store.ReadOption) ([]*store.Record, error) {
if err := n.initConn(); err != nil {
return nil, err
}
opt := store.ReadOptions{}
for _, o := range opts {
o(&opt)
}
if opt.Database == "" {
opt.Database = n.opts.Database
}
if opt.Table == "" {
opt.Table = n.opts.Table
}
bucket, ok := n.buckets.Get(opt.Database)
if !ok {
return nil, ErrBucketNotFound
}
keys, err := n.natsKeys(bucket, opt.Table, key, opt.Prefix, opt.Suffix)
if err != nil {
return nil, err
}
records := make([]*store.Record, 0, len(keys))
for _, key := range keys {
rec, ok, err := n.getRecord(bucket, key)
if err != nil {
return nil, err
}
if ok {
records = append(records, rec)
}
}
return enforceLimits(records, opt.Limit, opt.Offset), nil
}
// Write writes a record to the store, and returns an error if the record was not written.
func (n *natsStore) Write(rec *store.Record, opts ...store.WriteOption) error {
if err := n.initConn(); err != nil {
return err
}
opt := store.WriteOptions{}
for _, o := range opts {
o(&opt)
}
if opt.Database == "" {
opt.Database = n.opts.Database
}
if opt.Table == "" {
opt.Table = n.opts.Table
}
store, err := n.mustGetBucketByName(opt.Database)
if err != nil {
return err
}
b, err := json.Marshal(KeyValueEnvelope{
Key: rec.Key,
Data: rec.Value,
Metadata: rec.Metadata,
})
if err != nil {
return errors.Wrap(err, "Failed to marshal object")
}
if _, err := store.Put(n.NatsKey(opt.Table, rec.Key), b); err != nil {
return errors.Wrapf(err, "Failed to store data in bucket '%s'", n.NatsKey(opt.Table, rec.Key))
}
return nil
}
// Delete removes the record with the corresponding key from the store.
func (n *natsStore) Delete(key string, opts ...store.DeleteOption) error {
if err := n.initConn(); err != nil {
return err
}
opt := store.DeleteOptions{}
for _, o := range opts {
o(&opt)
}
if opt.Database == "" {
opt.Database = n.opts.Database
}
if opt.Table == "" {
opt.Table = n.opts.Table
}
if opt.Table == "DELETE_BUCKET" {
n.buckets.Del(key)
if err := n.js.DeleteKeyValue(key); err != nil {
return errors.Wrap(err, "Failed to delete bucket")
}
return nil
}
store, ok := n.buckets.Get(opt.Database)
if !ok {
return ErrBucketNotFound
}
if err := store.Delete(n.NatsKey(opt.Table, key)); err != nil {
return errors.Wrap(err, "Failed to delete data")
}
return nil
}
// List returns any keys that match, or an empty list with no error if none matched.
func (n *natsStore) List(opts ...store.ListOption) ([]string, error) {
if err := n.initConn(); err != nil {
return nil, err
}
opt := store.ListOptions{}
for _, o := range opts {
o(&opt)
}
if opt.Database == "" {
opt.Database = n.opts.Database
}
if opt.Table == "" {
opt.Table = n.opts.Table
}
store, ok := n.buckets.Get(opt.Database)
if !ok {
return nil, ErrBucketNotFound
}
keys, err := n.microKeys(store, opt.Table, opt.Prefix, opt.Suffix)
if err != nil {
return nil, errors.Wrap(err, "Failed to list keys in bucket")
}
return enforceLimits(keys, opt.Limit, opt.Offset), nil
}
// Close the store.
func (n *natsStore) Close() error {
n.conn.Close()
return nil
}
// String returns the name of the implementation.
func (n *natsStore) String() string {
return "NATS JetStream KeyValueStore"
}
// thread safe way to initialize the connection.
func (n *natsStore) initConn() error {
if n.hasConn() {
return nil
}
n.Lock()
defer n.Unlock()
// check if conn was initialized meanwhile
if n.conn != nil {
return nil
}
return n.Init()
}
// thread safe way to check if n is initialized.
func (n *natsStore) hasConn() bool {
n.RLock()
defer n.RUnlock()
return n.conn != nil
}
// mustGetDefaultBucket returns the bucket with the given name creating it with default configuration if needed.
func (n *natsStore) mustGetBucketByName(name string) (nats.KeyValue, error) {
return n.mustGetBucket(&nats.KeyValueConfig{
Bucket: name,
Description: n.description,
TTL: n.ttl,
Storage: n.storageType,
})
}
// mustGetBucket creates a new bucket if it does not exist yet.
func (n *natsStore) mustGetBucket(kv *nats.KeyValueConfig) (nats.KeyValue, error) {
if store, ok := n.buckets.Get(kv.Bucket); ok {
return store, nil
}
store, err := n.js.KeyValue(kv.Bucket)
if err != nil {
if !errors.Is(err, nats.ErrBucketNotFound) {
return nil, errors.Wrapf(err, "Failed to get bucket (%s)", kv.Bucket)
}
store, err = n.js.CreateKeyValue(kv)
if err != nil {
return nil, errors.Wrapf(err, "Failed to create bucket (%s)", kv.Bucket)
}
}
n.buckets.Set(kv.Bucket, store)
return store, nil
}
// getRecord returns the record with the given key from the nats kv store.
func (n *natsStore) getRecord(bucket nats.KeyValue, key string) (*store.Record, bool, error) {
obj, err := bucket.Get(key)
if errors.Is(err, nats.ErrKeyNotFound) {
return nil, false, store.ErrNotFound
} else if err != nil {
return nil, false, errors.Wrap(err, "Failed to get object from bucket")
}
var kv KeyValueEnvelope
if err := json.Unmarshal(obj.Value(), &kv); err != nil {
return nil, false, errors.Wrap(err, "Failed to unmarshal object")
}
if obj.Operation() != nats.KeyValuePut {
return nil, false, nil
}
return &store.Record{
Key: kv.Key,
Value: kv.Data,
Metadata: kv.Metadata,
}, true, nil
}
func (n *natsStore) natsKeys(bucket nats.KeyValue, table, key string, prefix, suffix bool) ([]string, error) {
if !suffix && !prefix {
return []string{n.NatsKey(table, key)}, nil
}
toS := func(s string, b bool) string {
if b {
return s
}
return ""
}
keys, _, err := n.getKeys(bucket, table, toS(key, prefix), toS(key, suffix))
return keys, err
}
func (n *natsStore) microKeys(bucket nats.KeyValue, table, prefix, suffix string) ([]string, error) {
_, keys, err := n.getKeys(bucket, table, prefix, suffix)
return keys, err
}
func (n *natsStore) getKeys(bucket nats.KeyValue, table string, prefix, suffix string) ([]string, []string, error) {
names, err := bucket.Keys(nats.IgnoreDeletes())
if errors.Is(err, nats.ErrKeyNotFound) {
return []string{}, []string{}, nil
} else if err != nil {
return []string{}, []string{}, errors.Wrap(err, "Failed to list objects")
}
natsKeys := make([]string, 0, len(names))
microKeys := make([]string, 0, len(names))
for _, k := range names {
mkey, ok := n.MicroKeyFilter(table, k, prefix, suffix)
if !ok {
continue
}
natsKeys = append(natsKeys, k)
microKeys = append(microKeys, mkey)
}
return natsKeys, microKeys, nil
}
// enforces offset and limit without causing a panic.
func enforceLimits[V any](recs []V, limit, offset uint) []V {
l := uint(len(recs))
from := offset
if from > l {
from = l
}
to := l
if limit > 0 && offset+limit < l {
to = offset + limit
}
return recs[from:to]
}

337
store/nats-js-kv/nats_test.go Normal file
View File

@ -0,0 +1,337 @@
package natsjskv
import (
"context"
"reflect"
"testing"
"time"
"github.com/google/uuid"
"github.com/nats-io/nats.go"
"github.com/pkg/errors"
"go-micro.dev/v5/store"
)
func TestNats(t *testing.T) {
// Setup without calling Init on purpose
var err error
for i := 0; i < 5; i++ {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
addr := startNatsServer(ctx, t)
s := NewStore(store.Nodes(addr), EncodeKeys())
// Test String method
t.Log("Testing:", s.String())
err = basicTest(t, s)
if err != nil {
t.Log(err)
continue
}
// Test reading non-existing key
r, err := s.Read("this-is-a-random-key")
if !errors.Is(err, store.ErrNotFound) {
t.Errorf("Expected %# v, got %# v", store.ErrNotFound, err)
}
if len(r) > 0 {
t.Fatal("Lenth should be 0")
}
err = s.Close()
if err != nil {
t.Logf("Failed to close store: %v", err)
}
cancel()
return
}
t.Fatal(err)
}
func TestOptions(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
s := testSetup(ctx, t,
DefaultMemory(),
// Having a non-default description will trigger nats.ErrStreamNameAlreadyInUse
// since the buckets have been created in previous tests with a different description.
//
// NOTE: this is only the case with a manually set up server, not with current
// test setup, where new servers are started for each test.
DefaultDescription("My fancy description"),
// Option has no effect in this context, just to test setting the option
JetStreamOptions(nats.PublishAsyncMaxPending(256)),
// Sets a custom NATS client name, just to test the NatsOptions() func
NatsOptions(nats.Options{Name: "Go NATS Store Plugin Tests Client"}),
KeyValueOptions(&nats.KeyValueConfig{
Bucket: "TestBucketName",
Description: "This bucket is not used",
TTL: 5 * time.Minute,
MaxBytes: 1024,
Storage: nats.MemoryStorage,
Replicas: 1,
}),
// Encode keys to avoid character limitations
EncodeKeys(),
)
defer cancel()
if err := basicTest(t, s); err != nil {
t.Fatal(err)
}
}
func TestTTL(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
ttl := 500 * time.Millisecond
s := testSetup(ctx, t,
DefaultTTL(ttl),
// Since these buckets will be new they will have the new description
DefaultDescription("My fancy description"),
)
defer cancel()
// Use a uuid to make sure a new bucket is created when using local server
id := uuid.New().String()
for _, r := range table {
if err := s.Write(r.Record, store.WriteTo(r.Database+id, r.Table)); err != nil {
t.Fatal(err)
}
}
time.Sleep(ttl * 2)
for _, r := range table {
res, err := s.Read(r.Record.Key, store.ReadFrom(r.Database+id, r.Table))
if !errors.Is(err, store.ErrNotFound) {
t.Errorf("Expected %# v, got %# v", store.ErrNotFound, err)
}
if len(res) > 0 {
t.Fatal("Fetched record while it should have expired")
}
}
}
func TestMetaData(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
s := testSetup(ctx, t)
defer cancel()
record := store.Record{
Key: "KeyOne",
Value: []byte("Some value"),
Metadata: map[string]interface{}{
"meta-one": "val",
"meta-two": 5,
},
Expiry: 0,
}
bucket := "meta-data-test"
if err := s.Write(&record, store.WriteTo(bucket, "")); err != nil {
t.Fatal(err)
}
r, err := s.Read(record.Key, store.ReadFrom(bucket, ""))
if err != nil {
t.Fatal(err)
}
if len(r) == 0 {
t.Fatal("No results found")
}
m := r[0].Metadata
if m["meta-one"].(string) != record.Metadata["meta-one"].(string) ||
m["meta-two"].(float64) != float64(record.Metadata["meta-two"].(int)) {
t.Fatalf("Metadata does not match: (%+v) != (%+v)", m, record.Metadata)
}
}
func TestDelete(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
s := testSetup(ctx, t)
defer cancel()
for _, r := range table {
if err := s.Write(r.Record, store.WriteTo(r.Database, r.Table)); err != nil {
t.Fatal(err)
}
if err := s.Delete(r.Record.Key, store.DeleteFrom(r.Database, r.Table)); err != nil {
t.Fatal(err)
}
time.Sleep(time.Second)
res, err := s.Read(r.Record.Key, store.ReadFrom(r.Database, r.Table))
if !errors.Is(err, store.ErrNotFound) {
t.Errorf("Expected %# v, got %# v", store.ErrNotFound, err)
}
if len(res) > 0 {
t.Fatalf("Failed to delete %s:%s from %s %s (len: %d)", r.Record.Key, r.Record.Value, r.Database, r.Table, len(res))
}
}
}
func TestList(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
s := testSetup(ctx, t)
defer cancel()
for _, r := range table {
if err := s.Write(r.Record, store.WriteTo(r.Database, r.Table)); err != nil {
t.Fatal(err)
}
}
l := []struct {
Database string
Table string
Length int
Prefix string
Suffix string
Offset int
Limit int
}{
{Length: 7},
{Database: "prefix-test", Length: 7},
{Database: "prefix-test", Offset: 2, Length: 5},
{Database: "prefix-test", Offset: 2, Limit: 3, Length: 3},
{Database: "prefix-test", Table: "names", Length: 3},
{Database: "prefix-test", Table: "cities", Length: 4},
{Database: "prefix-test", Table: "cities", Suffix: "City", Length: 3},
{Database: "prefix-test", Table: "cities", Suffix: "City", Limit: 2, Length: 2},
{Database: "prefix-test", Table: "cities", Suffix: "City", Offset: 1, Length: 2},
{Prefix: "test", Length: 1},
{Table: "some_table", Prefix: "test", Suffix: "test", Length: 2},
}
for i, entry := range l {
// Test listing keys
keys, err := s.List(
store.ListFrom(entry.Database, entry.Table),
store.ListPrefix(entry.Prefix),
store.ListSuffix(entry.Suffix),
store.ListOffset(uint(entry.Offset)),
store.ListLimit(uint(entry.Limit)),
)
if err != nil {
t.Fatal(err)
}
if len(keys) != entry.Length {
t.Fatalf("Length of returned keys is invalid for test %d - %+v (%d)", i+1, entry, len(keys))
}
// Test reading keys
if entry.Prefix != "" || entry.Suffix != "" {
var key string
options := []store.ReadOption{
store.ReadFrom(entry.Database, entry.Table),
store.ReadLimit(uint(entry.Limit)),
store.ReadOffset(uint(entry.Offset)),
}
if entry.Prefix != "" {
key = entry.Prefix
options = append(options, store.ReadPrefix())
}
if entry.Suffix != "" {
key = entry.Suffix
options = append(options, store.ReadSuffix())
}
r, err := s.Read(key, options...)
if err != nil {
t.Fatal(err)
}
if len(r) != entry.Length {
t.Fatalf("Length of read keys is invalid for test %d - %+v (%d)", i+1, entry, len(r))
}
}
}
}
func TestDeleteBucket(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
s := testSetup(ctx, t)
defer cancel()
for _, r := range table {
if err := s.Write(r.Record, store.WriteTo(r.Database, r.Table)); err != nil {
t.Fatal(err)
}
}
bucket := "prefix-test"
if err := s.Delete(bucket, DeleteBucket()); err != nil {
t.Fatal(err)
}
keys, err := s.List(store.ListFrom(bucket, ""))
if err != nil && !errors.Is(err, ErrBucketNotFound) {
t.Fatalf("Failed to delete bucket: %v", err)
}
if len(keys) > 0 {
t.Fatal("Length of key list should be 0 after bucket deletion")
}
r, err := s.Read("", store.ReadPrefix(), store.ReadFrom(bucket, ""))
if err != nil && !errors.Is(err, ErrBucketNotFound) {
t.Fatalf("Failed to delete bucket: %v", err)
}
if len(r) > 0 {
t.Fatal("Length of record list should be 0 after bucket deletion", len(r))
}
}
func TestEnforceLimits(t *testing.T) {
s := []string{"a", "b", "c", "d"}
var testCasts = []struct {
Alias string
Offset uint
Limit uint
Expected []string
}{
{"plain", 0, 0, []string{"a", "b", "c", "d"}},
{"offset&limit-1", 1, 3, []string{"b", "c", "d"}},
{"offset&limit-2", 1, 1, []string{"b"}},
{"offset=length", 4, 0, []string{}},
{"offset>length", 222, 0, []string{}},
{"limit>length", 0, 36, []string{"a", "b", "c", "d"}},
}
for _, tc := range testCasts {
actual := enforceLimits(s, tc.Limit, tc.Offset)
if !reflect.DeepEqual(actual, tc.Expected) {
t.Fatalf("%s: Expected %v, got %v", tc.Alias, tc.Expected, actual)
}
}
}
func basicTest(t *testing.T, s store.Store) error {
t.Helper()
for _, test := range table {
if err := s.Write(test.Record, store.WriteTo(test.Database, test.Table)); err != nil {
return errors.Wrap(err, "Failed to write record in basic test")
}
r, err := s.Read(test.Record.Key, store.ReadFrom(test.Database, test.Table))
if err != nil {
return errors.Wrap(err, "Failed to read record in basic test")
}
if len(r) == 0 {
t.Fatalf("No results found for %s (%s) %s", test.Record.Key, test.Database, test.Table)
}
key := test.Record.Key
val1 := string(test.Record.Value)
key2 := r[0].Key
val2 := string(r[0].Value)
if val1 != val2 {
t.Fatalf("Value not equal for (%s: %s) != (%s: %s)", key, val1, key2, val2)
}
}
return nil
}

83
store/nats-js-kv/options.go Normal file
View File

@ -0,0 +1,83 @@
package natsjskv
import (
"time"
"github.com/nats-io/nats.go"
"go-micro.dev/v5/store"
)
// store.Option.
type natsOptionsKey struct{}
type jsOptionsKey struct{}
type kvOptionsKey struct{}
type ttlOptionsKey struct{}
type memoryOptionsKey struct{}
type descriptionOptionsKey struct{}
type keyEncodeOptionsKey struct{}
// NatsOptions accepts nats.Options.
func NatsOptions(opts nats.Options) store.Option {
return setStoreOption(natsOptionsKey{}, opts)
}
// JetStreamOptions accepts multiple nats.JSOpt.
func JetStreamOptions(opts ...nats.JSOpt) store.Option {
return setStoreOption(jsOptionsKey{}, opts)
}
// KeyValueOptions accepts multiple nats.KeyValueConfig
// This will create buckets with the provided configs at initialization.
func KeyValueOptions(cfg ...*nats.KeyValueConfig) store.Option {
return setStoreOption(kvOptionsKey{}, cfg)
}
// DefaultTTL sets the default TTL to use for new buckets
//
// By default no TTL is set.
//
// TTL ON INDIVIDUAL WRITE CALLS IS NOT SUPPORTED, only bucket wide TTL.
// Either set a default TTL with this option or provide bucket specific options
//
// with ObjectStoreOptions
func DefaultTTL(ttl time.Duration) store.Option {
return setStoreOption(ttlOptionsKey{}, ttl)
}
// DefaultMemory sets the default storage type to memory only.
//
// The default is file storage, persisting storage between service restarts.
//
// Be aware that the default storage location of NATS the /tmp dir is, and thus
//
// won't persist reboots.
func DefaultMemory() store.Option {
return setStoreOption(memoryOptionsKey{}, nats.MemoryStorage)
}
// DefaultDescription sets the default description to use when creating new
//
// buckets. The default is "Store managed by go-micro"
func DefaultDescription(text string) store.Option {
return setStoreOption(descriptionOptionsKey{}, text)
}
// EncodeKeys will "base32" encode the keys.
// This is to work around limited characters usable as keys for the natsjs kv store.
// See details here: https://docs.nats.io/nats-concepts/subjects#characters-allowed-for-subject-names
func EncodeKeys() store.Option {
return setStoreOption(keyEncodeOptionsKey{}, "base32")
}
// DeleteBucket will use the key passed to Delete as a bucket (database) name,
//
// and delete the bucket.
//
// This option should not be combined with the store.DeleteFrom option, as
//
// that will overwrite the delete action.
func DeleteBucket() store.DeleteOption {
return func(d *store.DeleteOptions) {
d.Table = "DELETE_BUCKET"
}
}

138
store/nats-js-kv/test_data.go Normal file
View File

@ -0,0 +1,138 @@
package natsjskv
import "go-micro.dev/v5/store"
type test struct {
Record *store.Record
Database string
Table string
}
var (
table = []test{
{
Record: &store.Record{
Key: "One",
Value: []byte("First value"),
},
},
{
Record: &store.Record{
Key: "Two",
Value: []byte("Second value"),
},
Table: "prefix_test",
},
{
Record: &store.Record{
Key: "Third",
Value: []byte("Third value"),
},
Database: "new-bucket",
},
{
Record: &store.Record{
Key: "Four",
Value: []byte("Fourth value"),
},
Database: "new-bucket",
Table: "prefix_test",
},
{
Record: &store.Record{
Key: "empty-value",
Value: []byte{},
},
Database: "new-bucket",
},
{
Record: &store.Record{
Key: "Alex",
Value: []byte("Some value"),
},
Database: "prefix-test",
Table: "names",
},
{
Record: &store.Record{
Key: "Jones",
Value: []byte("Some value"),
},
Database: "prefix-test",
Table: "names",
},
{
Record: &store.Record{
Key: "Adrianna",
Value: []byte("Some value"),
},
Database: "prefix-test",
Table: "names",
},
{
Record: &store.Record{
Key: "MexicoCity",
Value: []byte("Some value"),
},
Database: "prefix-test",
Table: "cities",
},
{
Record: &store.Record{
Key: "HoustonCity",
Value: []byte("Some value"),
},
Database: "prefix-test",
Table: "cities",
},
{
Record: &store.Record{
Key: "ZurichCity",
Value: []byte("Some value"),
},
Database: "prefix-test",
Table: "cities",
},
{
Record: &store.Record{
Key: "Helsinki",
Value: []byte("Some value"),
},
Database: "prefix-test",
Table: "cities",
},
{
Record: &store.Record{
Key: "testKeytest",
Value: []byte("Some value"),
},
Table: "some_table",
},
{
Record: &store.Record{
Key: "testSecondtest",
Value: []byte("Some value"),
},
Table: "some_table",
},
{
Record: &store.Record{
Key: "lalala",
Value: []byte("Some value"),
},
Table: "some_table",
},
{
Record: &store.Record{
Key: "testAnothertest",
Value: []byte("Some value"),
},
},
{
Record: &store.Record{
Key: "FobiddenCharactersAreAllowed:|@..+",
Value: []byte("data no matter"),
},
},
}
)

13
store/postgres/README.md Normal file
View File

@ -0,0 +1,13 @@
# Postgres plugin
This module implements a Postgres implementation of the micro store interface.
## Implementation notes
### Concepts
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:
- micro database => Postgres schema
- micro table => Postgres table
### Expiry
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.

61
store/postgres/metadata.go Normal file
View File

@ -0,0 +1,61 @@
// Copyright 2020 Asim Aslam
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Original source: github.com/micro/go-plugins/v3/store/cockroach/metadata.go
package postgres
import (
"database/sql/driver"
"encoding/json"
"errors"
)
// https://github.com/upper/db/blob/master/postgresql/custom_types.go#L43
type Metadata map[string]interface{}
// Scan satisfies the sql.Scanner interface.
func (m *Metadata) Scan(src interface{}) error {
source, ok := src.([]byte)
if !ok {
return errors.New("Type assertion .([]byte) failed.")
}
var i interface{}
err := json.Unmarshal(source, &i)
if err != nil {
return err
}
*m, ok = i.(map[string]interface{})
if !ok {
return errors.New("Type assertion .(map[string]interface{}) failed.")
}
return nil
}
// Value satisfies the driver.Valuer interface.
func (m Metadata) Value() (driver.Value, error) {
j, err := json.Marshal(m)
return j, err
}
func toMetadata(m *Metadata) map[string]interface{} {
md := make(map[string]interface{})
for k, v := range *m {
md[k] = v
}
return md
}

14
store/postgres/pgx/README.md Normal file
View File

@ -0,0 +1,14 @@
# Postgres pgx plugin
This module implements a Postgres implementation of the micro store interface.
It uses modern https://github.com/jackc/pgx driver to access Postgres.
## Implementation notes
### Concepts
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:
- micro database => Postgres schema
- micro table => Postgres table
### Expiry
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.

8
store/postgres/pgx/db.go Normal file
View File

@ -0,0 +1,8 @@
package pgx
import "github.com/jackc/pgx/v4/pgxpool"
type DB struct {
conn *pgxpool.Pool
tables map[string]Queries
}

44
store/postgres/pgx/metadata.go Normal file
View File

@ -0,0 +1,44 @@
package pgx
import (
"database/sql/driver"
"encoding/json"
"errors"
)
type Metadata map[string]interface{}
// Scan satisfies the sql.Scanner interface.
func (m *Metadata) Scan(src interface{}) error {
source, ok := src.([]byte)
if !ok {
return errors.New("type assertion .([]byte) failed")
}
var i interface{}
err := json.Unmarshal(source, &i)
if err != nil {
return err
}
*m, ok = i.(map[string]interface{})
if !ok {
return errors.New("type assertion .(map[string]interface{}) failed")
}
return nil
}
// Value satisfies the driver.Valuer interface.
func (m *Metadata) Value() (driver.Value, error) {
j, err := json.Marshal(m)
return j, err
}
func toMetadata(m *Metadata) map[string]interface{} {
md := make(map[string]interface{})
for k, v := range *m {
md[k] = v
}
return md
}

427
store/postgres/pgx/pgx.go Normal file
View File

@ -0,0 +1,427 @@
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package pgx implements the postgres store with pgx driver
package pgx
import (
"database/sql"
"fmt"
"net/url"
"regexp"
"strings"
"sync"
"time"
"github.com/jackc/pgx/v4"
"github.com/jackc/pgx/v4/pgxpool"
"github.com/pkg/errors"
"go-micro.dev/v5/logger"
"go-micro.dev/v5/store"
)
const defaultDatabase = "micro"
const defaultTable = "micro"
type sqlStore struct {
options store.Options
re *regexp.Regexp
sync.Mutex
// known databases
databases map[string]DB
}
func (s *sqlStore) getDB(database, table string) (string, string) {
if len(database) == 0 {
if len(s.options.Database) > 0 {
database = s.options.Database
} else {
database = defaultDatabase
}
}
if len(table) == 0 {
if len(s.options.Table) > 0 {
table = s.options.Table
} else {
table = defaultTable
}
}
// store.namespace must only contain letters, numbers and underscores
database = s.re.ReplaceAllString(database, "_")
table = s.re.ReplaceAllString(table, "_")
return database, table
}
func (s *sqlStore) db(database, table string) (*pgxpool.Pool, Queries, error) {
s.Lock()
defer s.Unlock()
database, table = s.getDB(database, table)
if _, ok := s.databases[database]; !ok {
err := s.initDB(database)
if err != nil {
return nil, Queries{}, err
}
}
dbObj := s.databases[database]
if _, ok := dbObj.tables[table]; !ok {
err := s.initTable(database, table)
if err != nil {
return nil, Queries{}, err
}
}
return dbObj.conn, dbObj.tables[table], nil
}
func (s *sqlStore) initTable(database, table string) error {
db := s.databases[database].conn
_, err := db.Exec(s.options.Context, fmt.Sprintf(createTable, database, table))
if err != nil {
return errors.Wrap(err, "cannot create table")
}
_, err = db.Exec(s.options.Context, fmt.Sprintf(createMDIndex, table, database, table))
if err != nil {
return errors.Wrap(err, "cannot create metadata index")
}
_, err = db.Exec(s.options.Context, fmt.Sprintf(createExpiryIndex, table, database, table))
if err != nil {
return errors.Wrap(err, "cannot create expiry index")
}
s.databases[database].tables[table] = NewQueries(database, table)
return nil
}
func (s *sqlStore) initDB(database string) error {
if len(s.options.Nodes) == 0 {
s.options.Nodes = []string{"postgresql://root@localhost:26257?sslmode=disable"}
}
source := s.options.Nodes[0]
// check if it is a standard connection string eg: host=%s port=%d user=%s password=%s dbname=%s sslmode=disable
// if err is nil which means it would be a URL like postgre://xxxx?yy=zz
_, err := url.Parse(source)
if err != nil {
if !strings.Contains(source, " ") {
source = fmt.Sprintf("host=%s", source)
}
}
config, err := pgxpool.ParseConfig(source)
if err != nil {
return err
}
db, err := pgxpool.ConnectConfig(s.options.Context, config)
if err != nil {
return err
}
if err = db.Ping(s.options.Context); err != nil {
return err
}
_, err = db.Exec(s.options.Context, fmt.Sprintf(createSchema, database))
if err != nil {
return err
}
if len(database) == 0 {
if len(s.options.Database) > 0 {
database = s.options.Database
} else {
database = defaultDatabase
}
}
// save the values
s.databases[database] = DB{
conn: db,
tables: make(map[string]Queries),
}
return nil
}
func (s *sqlStore) Close() error {
for _, obj := range s.databases {
obj.conn.Close()
}
return nil
}
func (s *sqlStore) Init(opts ...store.Option) error {
for _, o := range opts {
o(&s.options)
}
_, _, err := s.db(s.options.Database, s.options.Table)
return err
}
// List all the known records
func (s *sqlStore) List(opts ...store.ListOption) ([]string, error) {
options := store.ListOptions{}
for _, o := range opts {
o(&options)
}
db, queries, err := s.db(options.Database, options.Table)
if err != nil {
return nil, err
}
pattern := "%"
if options.Prefix != "" {
pattern = options.Prefix + pattern
}
if options.Suffix != "" {
pattern = pattern + options.Suffix
}
var rows pgx.Rows
if options.Limit > 0 {
rows, err = db.Query(s.options.Context, queries.ListAscLimit, pattern, options.Limit, options.Offset)
} else {
rows, err = db.Query(s.options.Context, queries.ListAsc, pattern)
}
if err != nil {
if err == pgx.ErrNoRows {
return nil, nil
}
return nil, err
}
defer rows.Close()
keys := make([]string, 0, 10)
for rows.Next() {
var key string
err = rows.Scan(&key)
if err != nil {
return nil, err
}
keys = append(keys, key)
}
return keys, nil
}
// rowToRecord converts from pgx.Row to a store.Record
func (s *sqlStore) rowToRecord(row pgx.Row) (*store.Record, error) {
var expiry *time.Time
record := &store.Record{}
metadata := make(Metadata)
if err := row.Scan(&record.Key, &record.Value, &metadata, &expiry); err != nil {
if err == sql.ErrNoRows {
return record, store.ErrNotFound
}
return nil, err
}
// set the metadata
record.Metadata = toMetadata(&metadata)
if expiry != nil {
record.Expiry = time.Until(*expiry)
}
return record, nil
}
// rowsToRecords converts from pgx.Rows to []*store.Record
func (s *sqlStore) rowsToRecords(rows pgx.Rows) ([]*store.Record, error) {
var records []*store.Record
for rows.Next() {
var expiry *time.Time
record := &store.Record{}
metadata := make(Metadata)
if err := rows.Scan(&record.Key, &record.Value, &metadata, &expiry); err != nil {
return records, err
}
// set the metadata
record.Metadata = toMetadata(&metadata)
if expiry != nil {
record.Expiry = time.Until(*expiry)
}
records = append(records, record)
}
return records, nil
}
// Read a single key
func (s *sqlStore) Read(key string, opts ...store.ReadOption) ([]*store.Record, error) {
options := store.ReadOptions{
}
for _, o := range opts {
o(&options)
}
db, queries, err := s.db(options.Database, options.Table)
if err != nil {
return nil, err
}
// read one record
if !options.Prefix && !options.Suffix {
row := db.QueryRow(s.options.Context, queries.ReadOne, key)
record, err := s.rowToRecord(row)
if err != nil {
return nil, err
}
return []*store.Record{record}, nil
}
// read by pattern
pattern := "%"
if options.Prefix {
pattern = key + pattern
}
if options.Suffix {
pattern = pattern + key
}
var rows pgx.Rows
if options.Limit > 0 {
rows, err = db.Query(s.options.Context, queries.ListAscLimit, pattern, options.Limit, options.Offset)
} else {
rows, err = db.Query(s.options.Context, queries.ListAsc, pattern)
}
if err != nil {
if err == pgx.ErrNoRows {
return nil, nil
}
return nil, err
}
defer rows.Close()
return s.rowsToRecords(rows)
}
// Write records
func (s *sqlStore) Write(r *store.Record, opts ...store.WriteOption) error {
var options store.WriteOptions
for _, o := range opts {
o(&options)
}
db, queries, err := s.db(options.Database, options.Table)
if err != nil {
return err
}
metadata := make(Metadata)
for k, v := range r.Metadata {
metadata[k] = v
}
if r.Expiry != 0 {
_, err = db.Exec(s.options.Context, queries.Write, r.Key, r.Value, metadata, time.Now().Add(r.Expiry))
} else {
_, err = db.Exec(s.options.Context, queries.Write, r.Key, r.Value, metadata, nil)
}
if err != nil {
return errors.Wrap(err, "cannot upsert record "+r.Key)
}
return nil
}
// Delete records with keys
func (s *sqlStore) Delete(key string, opts ...store.DeleteOption) error {
var options store.DeleteOptions
for _, o := range opts {
o(&options)
}
db, queries, err := s.db(options.Database, options.Table)
if err != nil {
return err
}
_, err = db.Exec(s.options.Context, queries.Delete, key)
return err
}
func (s *sqlStore) Options() store.Options {
return s.options
}
func (s *sqlStore) String() string {
return "pgx"
}
// NewStore returns a new micro Store backed by sql
func NewStore(opts ...store.Option) store.Store {
options := store.Options{
Database: defaultDatabase,
Table: defaultTable,
}
for _, o := range opts {
o(&options)
}
// new store
s := new(sqlStore)
s.options = options
s.databases = make(map[string]DB)
s.re = regexp.MustCompile("[^a-zA-Z0-9]+")
go s.expiryLoop()
// return store
return s
}
func (s *sqlStore) expiryLoop() {
for {
err := s.expireRows()
if err != nil {
logger.Errorf("error cleaning up %s", err)
}
time.Sleep(1 * time.Hour)
}
}
func (s *sqlStore) expireRows() error {
for database, dbObj := range s.databases {
db := dbObj.conn
for table, queries := range dbObj.tables {
res, err := db.Exec(s.options.Context, queries.DeleteExpired)
if err != nil {
logger.Errorf("Error cleaning up %s", err)
return err
}
logger.Infof("Cleaning up %s %s: %d rows deleted", database, table, res.RowsAffected())
}
}
return nil
}

139
store/postgres/pgx/pgx_test.go Normal file
View File

@ -0,0 +1,139 @@
//go:build integration
// +build integration
package pgx
import (
"encoding/json"
"testing"
"github.com/stretchr/testify/assert"
"go-micro.dev/v5/store"
)
type testObj struct {
One string
Two int64
}
func TestPostgres(t *testing.T) {
t.Run("ReadWrite", func(t *testing.T) {
s := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"))
b, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err := s.Write(&store.Record{
Key: "foobar/baz",
Value: b,
Metadata: map[string]interface{}{
"meta1": "val1",
},
})
assert.NoError(t, err)
recs, err := s.Read("foobar/baz")
assert.NoError(t, err)
assert.Len(t, recs, 1)
assert.Equal(t, "foobar/baz", recs[0].Key)
assert.Len(t, recs[0].Metadata, 1)
assert.Equal(t, "val1", recs[0].Metadata["meta1"])
var tobj testObj
assert.NoError(t, json.Unmarshal(recs[0].Value, &tobj))
assert.Equal(t, "1", tobj.One)
assert.Equal(t, int64(2), tobj.Two)
})
t.Run("Prefix", func(t *testing.T) {
s := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"))
b, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err := s.Write(&store.Record{
Key: "foo/bar",
Value: b,
Metadata: map[string]interface{}{
"meta1": "val1",
},
})
assert.NoError(t, err)
err = s.Write(&store.Record{
Key: "foo/baz",
Value: b,
Metadata: map[string]interface{}{
"meta1": "val1",
},
})
assert.NoError(t, err)
recs, err := s.Read("foo/", store.ReadPrefix())
assert.NoError(t, err)
assert.Len(t, recs, 2)
assert.Equal(t, "foo/bar", recs[0].Key)
assert.Equal(t, "foo/baz", recs[1].Key)
})
t.Run("MultipleTables", func(t *testing.T) {
s1 := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"), store.Table("t1"))
s2 := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"), store.Table("t2"))
b1, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err := s1.Write(&store.Record{
Key: "foo/bar",
Value: b1,
})
assert.NoError(t, err)
b2, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err = s2.Write(&store.Record{
Key: "foo/baz",
Value: b2,
})
assert.NoError(t, err)
recs1, err := s1.List()
assert.NoError(t, err)
assert.Len(t, recs1, 1)
assert.Equal(t, "foo/bar", recs1[0])
recs2, err := s2.List()
assert.NoError(t, err)
assert.Len(t, recs2, 1)
assert.Equal(t, "foo/baz", recs2[0])
})
t.Run("MultipleDBs", func(t *testing.T) {
s1 := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"), store.Database("d1"))
s2 := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"), store.Database("d2"))
b1, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err := s1.Write(&store.Record{
Key: "foo/bar",
Value: b1,
})
assert.NoError(t, err)
b2, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err = s2.Write(&store.Record{
Key: "foo/baz",
Value: b2,
})
assert.NoError(t, err)
recs1, err := s1.List()
assert.NoError(t, err)
assert.Len(t, recs1, 1)
assert.Equal(t, "foo/bar", recs1[0])
recs2, err := s2.List()
assert.NoError(t, err)
assert.Len(t, recs2, 1)
assert.Equal(t, "foo/baz", recs2[0])
})
}

38
store/postgres/pgx/queries.go Normal file
View File

@ -0,0 +1,38 @@
package pgx
import "fmt"
type Queries struct {
// read
ListAsc string
ListAscLimit string
ListDesc string
ListDescLimit string
ReadOne string
ReadManyAsc string
ReadManyAscLimit string
ReadManyDesc string
ReadManyDescLimit string
// change
Write string
Delete string
DeleteExpired string
}
func NewQueries(database, table string) Queries {
return Queries{
ListAsc: fmt.Sprintf(list, database, table) + asc,
ListAscLimit: fmt.Sprintf(list, database, table) + asc + limit,
ListDesc: fmt.Sprintf(list, database, table) + desc,
ListDescLimit: fmt.Sprintf(list, database, table) + desc + limit,
ReadOne: fmt.Sprintf(readOne, database, table),
ReadManyAsc: fmt.Sprintf(readMany, database, table) + asc,
ReadManyAscLimit: fmt.Sprintf(readMany, database, table) + asc + limit,
ReadManyDesc: fmt.Sprintf(readMany, database, table) + desc,
ReadManyDescLimit: fmt.Sprintf(readMany, database, table) + desc + limit,
Write: fmt.Sprintf(write, database, table),
Delete: fmt.Sprintf(deleteRecord, database, table),
DeleteExpired: fmt.Sprintf(deleteExpired, database, table),
}
}

35
store/postgres/pgx/templates.go Normal file
View File

@ -0,0 +1,35 @@
package pgx
// init
const createSchema = "CREATE SCHEMA IF NOT EXISTS %s"
const createTable = `CREATE TABLE IF NOT EXISTS %s.%s
(
key text primary key,
value bytea,
metadata JSONB,
expiry timestamp with time zone
)`
const createMDIndex = `create index if not exists idx_md_%s ON %s.%s USING GIN (metadata)`
const createExpiryIndex = `create index if not exists idx_expiry_%s on %s.%s (expiry) where (expiry IS NOT NULL)`
// base queries
const (
list = "SELECT key FROM %s.%s WHERE key LIKE $1 and (expiry < now() or expiry isnull)"
readOne = "SELECT key, value, metadata, expiry FROM %s.%s WHERE key = $1 and (expiry < now() or expiry isnull)"
readMany = "SELECT key, value, metadata, expiry FROM %s.%s WHERE key LIKE $1 and (expiry < now() or expiry isnull)"
write = `INSERT INTO %s.%s(key, value, metadata, expiry)
VALUES ($1, $2::bytea, $3, $4)
ON CONFLICT (key)
DO UPDATE
SET value = EXCLUDED.value, metadata = EXCLUDED.metadata, expiry = EXCLUDED.expiry`
deleteRecord = "DELETE FROM %s.%s WHERE key = $1"
deleteExpired = "DELETE FROM %s.%s WHERE expiry < now()"
)
// suffixes
const (
limit = " LIMIT $2 OFFSET $3"
asc = " ORDER BY key ASC"
desc = " ORDER BY key DESC"
)

663
store/postgres/postgres.go Normal file
View File

@ -0,0 +1,663 @@
// Copyright 2020 Asim Aslam
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Original source: github.com/micro/go-plugins/v3/store/cockroach/cockroach.go
// Package postgres implements the postgres store
package postgres
import (
"database/sql"
"database/sql/driver"
"fmt"
"net"
"net/url"
"regexp"
"strings"
"sync"
"syscall"
"time"
"github.com/lib/pq"
"github.com/pkg/errors"
"go-micro.dev/v5/logger"
"go-micro.dev/v5/store"
)
// DefaultDatabase is the namespace that the sql store
// will use if no namespace is provided.
var (
DefaultDatabase = "micro"
DefaultTable = "micro"
ErrNoConnection = errors.New("Database connection not initialised")
)
var (
re = regexp.MustCompile("[^a-zA-Z0-9]+")
// alternative ordering
orderAsc = "ORDER BY key ASC"
orderDesc = "ORDER BY key DESC"
// the sql statements we prepare and use
statements = map[string]string{
"list": "SELECT key, value, metadata, expiry FROM %s.%s WHERE key LIKE $1 ORDER BY key ASC LIMIT $2 OFFSET $3;",
"read": "SELECT key, value, metadata, expiry FROM %s.%s WHERE key = $1;",
"readMany": "SELECT key, value, metadata, expiry FROM %s.%s WHERE key LIKE $1 ORDER BY key ASC;",
"readOffset": "SELECT key, value, metadata, expiry FROM %s.%s WHERE key LIKE $1 ORDER BY key ASC LIMIT $2 OFFSET $3;",
"write": "INSERT INTO %s.%s(key, value, metadata, expiry) VALUES ($1, $2::bytea, $3, $4) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, metadata = EXCLUDED.metadata, expiry = EXCLUDED.expiry;",
"delete": "DELETE FROM %s.%s WHERE key = $1;",
"deleteExpired": "DELETE FROM %s.%s WHERE expiry < now();",
"showTables": "SELECT schemaname, tablename FROM pg_catalog.pg_tables WHERE schemaname != 'pg_catalog' AND schemaname != 'information_schema';",
}
)
type sqlStore struct {
options store.Options
dbConn *sql.DB
sync.RWMutex
// known databases
databases map[string]bool
}
func (s *sqlStore) getDB(database, table string) (string, string) {
if len(database) == 0 {
if len(s.options.Database) > 0 {
database = s.options.Database
} else {
database = DefaultDatabase
}
}
if len(table) == 0 {
if len(s.options.Table) > 0 {
table = s.options.Table
} else {
table = DefaultTable
}
}
// store.namespace must only contain letters, numbers and underscores
database = re.ReplaceAllString(database, "_")
table = re.ReplaceAllString(table, "_")
return database, table
}
// createDB ensures that the DB and table have been created. It's used for lazy initialisation
// and will record which tables have been created to reduce calls to the DB
func (s *sqlStore) createDB(database, table string) error {
database, table = s.getDB(database, table)
s.Lock()
defer s.Unlock()
if _, ok := s.databases[database+":"+table]; ok {
return nil
}
if err := s.initDB(database, table); err != nil {
return err
}
s.databases[database+":"+table] = true
return nil
}
// db returns a valid connection to the DB
func (s *sqlStore) db() (*sql.DB, error) {
if s.dbConn == nil {
return nil, ErrNoConnection
}
if err := s.dbConn.Ping(); err != nil {
if !isBadConnError(err) {
return nil, err
}
logger.Errorf("Error with DB connection, will reconfigure: %s", err)
if err := s.configure(); err != nil {
logger.Errorf("Error while reconfiguring client: %s", err)
return nil, err
}
}
return s.dbConn, nil
}
// isBadConnError returns true if the error is related to having a bad connection such that you need to reconnect
func isBadConnError(err error) bool {
if err == nil {
return false
}
if err == driver.ErrBadConn {
return true
}
// heavy handed crude check for "connection reset by peer"
if strings.Contains(err.Error(), syscall.ECONNRESET.Error()) {
return true
}
// otherwise iterate through the error types
switch t := err.(type) {
case syscall.Errno:
return t == syscall.ECONNRESET || t == syscall.ECONNABORTED || t == syscall.ECONNREFUSED
case *net.OpError:
return !t.Temporary()
case net.Error:
return !t.Temporary()
}
return false
}
func (s *sqlStore) initDB(database, table string) error {
db, err := s.db()
if err != nil {
return err
}
// Create the namespace's database
_, err = db.Exec(fmt.Sprintf("CREATE DATABASE %s;", database))
if err != nil && !strings.Contains(err.Error(), "already exists") {
return err
}
var version string
if err = db.QueryRow("select version()").Scan(&version); err == nil {
if strings.Contains(version, "PostgreSQL") {
_, err = db.Exec(fmt.Sprintf("CREATE SCHEMA IF NOT EXISTS %s;", database))
if err != nil {
return err
}
}
}
// Create a table for the namespace's prefix
_, err = db.Exec(fmt.Sprintf(`CREATE TABLE IF NOT EXISTS %s.%s
(
key text NOT NULL,
value bytea,
metadata JSONB,
expiry timestamp with time zone,
CONSTRAINT %s_pkey PRIMARY KEY (key)
);`, database, table, table))
if err != nil {
return errors.Wrap(err, "Couldn't create table")
}
// Create Index
_, err = db.Exec(fmt.Sprintf(`CREATE INDEX IF NOT EXISTS "%s" ON %s.%s USING btree ("key");`, "key_index_"+table, database, table))
if err != nil {
return err
}
// Create Metadata Index
_, err = db.Exec(fmt.Sprintf(`CREATE INDEX IF NOT EXISTS "%s" ON %s.%s USING GIN ("metadata");`, "metadata_index_"+table, database, table))
if err != nil {
return err
}
return nil
}
func (s *sqlStore) configure() error {
if len(s.options.Nodes) == 0 {
s.options.Nodes = []string{"postgresql://root@localhost:26257?sslmode=disable"}
}
source := s.options.Nodes[0]
// check if it is a standard connection string eg: host=%s port=%d user=%s password=%s dbname=%s sslmode=disable
// if err is nil which means it would be a URL like postgre://xxxx?yy=zz
_, err := url.Parse(source)
if err != nil {
if !strings.Contains(source, " ") {
source = fmt.Sprintf("host=%s", source)
}
}
// create source from first node
db, err := sql.Open("postgres", source)
if err != nil {
return err
}
if err := db.Ping(); err != nil {
return err
}
if s.dbConn != nil {
s.dbConn.Close()
}
// save the values
s.dbConn = db
// get DB
database, table := s.getDB(s.options.Database, s.options.Table)
// initialise the database
return s.initDB(database, table)
}
func (s *sqlStore) prepare(database, table, query string) (*sql.Stmt, error) {
st, ok := statements[query]
if !ok {
return nil, errors.New("unsupported statement")
}
// get DB
database, table = s.getDB(database, table)
q := fmt.Sprintf(st, database, table)
db, err := s.db()
if err != nil {
return nil, err
}
stmt, err := db.Prepare(q)
if err != nil {
return nil, err
}
return stmt, nil
}
func (s *sqlStore) Close() error {
if s.dbConn != nil {
return s.dbConn.Close()
}
return nil
}
func (s *sqlStore) Init(opts ...store.Option) error {
for _, o := range opts {
o(&s.options)
}
// reconfigure
return s.configure()
}
// List all the known records
func (s *sqlStore) List(opts ...store.ListOption) ([]string, error) {
options := store.ListOptions{}
for _, o := range opts {
o(&options)
}
// create the db if not exists
if err := s.createDB(options.Database, options.Table); err != nil {
return nil, err
}
limit := sql.NullInt32{}
offset := 0
pattern := "%"
if options.Prefix != "" || options.Suffix != "" {
if options.Prefix != "" {
pattern = options.Prefix + pattern
}
if options.Suffix != "" {
pattern = pattern + options.Suffix
}
}
if options.Offset > 0 {
offset = int(options.Offset)
}
if options.Limit > 0 {
limit = sql.NullInt32{Int32: int32(options.Limit), Valid: true}
}
st, err := s.prepare(options.Database, options.Table, "list")
if err != nil {
return nil, err
}
defer st.Close()
rows, err := st.Query(pattern, limit, offset)
if err != nil {
if err == sql.ErrNoRows {
return nil, nil
}
return nil, err
}
defer rows.Close()
var keys []string
records, err := s.rowsToRecords(rows)
if err != nil {
return nil, err
}
for _, k := range records {
keys = append(keys, k.Key)
}
rowErr := rows.Close()
if rowErr != nil {
// transaction rollback or something
return keys, rowErr
}
if err := rows.Err(); err != nil {
return keys, err
}
return keys, nil
}
// rowToRecord converts from sql.Row to a store.Record. If the record has expired it will issue a delete in a separate goroutine
func (s *sqlStore) rowToRecord(row *sql.Row) (*store.Record, error) {
var timehelper pq.NullTime
record := &store.Record{}
metadata := make(Metadata)
if err := row.Scan(&record.Key, &record.Value, &metadata, &timehelper); err != nil {
if err == sql.ErrNoRows {
return record, store.ErrNotFound
}
return nil, err
}
// set the metadata
record.Metadata = toMetadata(&metadata)
if timehelper.Valid {
if timehelper.Time.Before(time.Now()) {
// record has expired
go s.Delete(record.Key)
return nil, store.ErrNotFound
}
record.Expiry = time.Until(timehelper.Time)
}
return record, nil
}
// rowsToRecords converts from sql.Rows to []*store.Record. If a record has expired it will issue a delete in a separate goroutine
func (s *sqlStore) rowsToRecords(rows *sql.Rows) ([]*store.Record, error) {
var records []*store.Record
var timehelper pq.NullTime
for rows.Next() {
record := &store.Record{}
metadata := make(Metadata)
if err := rows.Scan(&record.Key, &record.Value, &metadata, &timehelper); err != nil {
return records, err
}
// set the metadata
record.Metadata = toMetadata(&metadata)
if timehelper.Valid {
if timehelper.Time.Before(time.Now()) {
// record has expired
go s.Delete(record.Key)
} else {
record.Expiry = time.Until(timehelper.Time)
records = append(records, record)
}
} else {
records = append(records, record)
}
}
return records, nil
}
// Read a single key
func (s *sqlStore) Read(key string, opts ...store.ReadOption) ([]*store.Record, error) {
options := store.ReadOptions{}
for _, o := range opts {
o(&options)
}
// create the db if not exists
if err := s.createDB(options.Database, options.Table); err != nil {
return nil, err
}
if options.Prefix || options.Suffix {
return s.read(key, options)
}
st, err := s.prepare(options.Database, options.Table, "read")
if err != nil {
return nil, err
}
defer st.Close()
row := st.QueryRow(key)
record, err := s.rowToRecord(row)
if err != nil {
return nil, err
}
var records []*store.Record
return append(records, record), nil
}
// Read Many records
func (s *sqlStore) read(key string, options store.ReadOptions) ([]*store.Record, error) {
pattern := "%"
if options.Prefix {
pattern = key + pattern
}
if options.Suffix {
pattern = pattern + key
}
var rows *sql.Rows
var st *sql.Stmt
var err error
if options.Limit != 0 {
st, err = s.prepare(options.Database, options.Table, "readOffset")
if err != nil {
return nil, err
}
defer st.Close()
rows, err = st.Query(pattern, options.Limit, options.Offset)
} else {
st, err = s.prepare(options.Database, options.Table, "readMany")
if err != nil {
return nil, err
}
defer st.Close()
rows, err = st.Query(pattern)
}
if err != nil {
if err == sql.ErrNoRows {
return []*store.Record{}, nil
}
return []*store.Record{}, errors.Wrap(err, "sqlStore.read failed")
}
defer rows.Close()
records, err := s.rowsToRecords(rows)
if err != nil {
return nil, err
}
rowErr := rows.Close()
if rowErr != nil {
// transaction rollback or something
return records, rowErr
}
if err := rows.Err(); err != nil {
return records, err
}
return records, nil
}
// Write records
func (s *sqlStore) Write(r *store.Record, opts ...store.WriteOption) error {
var options store.WriteOptions
for _, o := range opts {
o(&options)
}
// create the db if not exists
if err := s.createDB(options.Database, options.Table); err != nil {
return err
}
st, err := s.prepare(options.Database, options.Table, "write")
if err != nil {
return err
}
defer st.Close()
metadata := make(Metadata)
for k, v := range r.Metadata {
metadata[k] = v
}
var expiry time.Time
if r.Expiry != 0 {
expiry = time.Now().Add(r.Expiry)
}
if expiry.IsZero() {
_, err = st.Exec(r.Key, r.Value, metadata, nil)
} else {
_, err = st.Exec(r.Key, r.Value, metadata, expiry)
}
if err != nil {
return errors.Wrap(err, "Couldn't insert record "+r.Key)
}
return nil
}
// Delete records with keys
func (s *sqlStore) Delete(key string, opts ...store.DeleteOption) error {
var options store.DeleteOptions
for _, o := range opts {
o(&options)
}
// create the db if not exists
if err := s.createDB(options.Database, options.Table); err != nil {
return err
}
st, err := s.prepare(options.Database, options.Table, "delete")
if err != nil {
return err
}
defer st.Close()
result, err := st.Exec(key)
if err != nil {
return err
}
_, err = result.RowsAffected()
if err != nil {
return err
}
return nil
}
func (s *sqlStore) Options() store.Options {
return s.options
}
func (s *sqlStore) String() string {
return "cockroach"
}
// NewStore returns a new micro Store backed by sql
func NewStore(opts ...store.Option) store.Store {
options := store.Options{
Database: DefaultDatabase,
Table: DefaultTable,
}
for _, o := range opts {
o(&options)
}
// new store
s := new(sqlStore)
// set the options
s.options = options
// mark known databases
s.databases = make(map[string]bool)
// best-effort configure the store
if err := s.configure(); err != nil {
if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
logger.Error("Error configuring store ", err)
}
}
go s.expiryLoop()
// return store
return s
}
func (s *sqlStore) expiryLoop() {
for {
s.expireRows()
time.Sleep(1 * time.Hour)
}
}
func (s *sqlStore) expireRows() error {
db, err := s.db()
if err != nil {
logger.Errorf("Error getting DB connection %s", err)
return err
}
stmt, err := db.Prepare(statements["showTables"])
if err != nil {
logger.Errorf("Error prepping show tables query %s", err)
return err
}
defer stmt.Close()
rows, err := stmt.Query()
if err != nil {
logger.Errorf("Error running show tables query %s", err)
return err
}
defer rows.Close()
for rows.Next() {
var schemaName, tableName string
if err := rows.Scan(&schemaName, &tableName); err != nil {
logger.Errorf("Error parsing result %s", err)
return err
}
db, err = s.db()
if err != nil {
logger.Errorf("Error prepping delete expired query %s", err)
return err
}
delStmt, err := db.Prepare(fmt.Sprintf(statements["deleteExpired"], schemaName, tableName))
if err != nil {
logger.Errorf("Error prepping delete expired query %s", err)
return err
}
defer delStmt.Close()
res, err := delStmt.Exec()
if err != nil {
logger.Errorf("Error cleaning up %s", err)
return err
}
r, _ := res.RowsAffected()
logger.Infof("Cleaning up %s %s: %d rows deleted", schemaName, tableName, r)
}
return nil
}

148
store/postgres/postgres_test.go Normal file
View File

@ -0,0 +1,148 @@
//go:build integration
// +build integration
package postgres
import (
"encoding/json"
"testing"
"github.com/stretchr/testify/assert"
"go-micro.dev/v5/store"
)
type testObj struct {
One string
Two int64
}
func TestPostgres(t *testing.T) {
t.Run("ReadWrite", func(t *testing.T) {
s := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"))
base := s.(*sqlStore)
base.dbConn.Exec("DROP SCHENA IF EXISTS micro")
b, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err := s.Write(&store.Record{
Key: "foobar/baz",
Value: b,
Metadata: map[string]interface{}{
"meta1": "val1",
},
})
assert.NoError(t, err)
recs, err := s.Read("foobar/baz")
assert.NoError(t, err)
assert.Len(t, recs, 1)
assert.Equal(t, "foobar/baz", recs[0].Key)
assert.Len(t, recs[0].Metadata, 1)
assert.Equal(t, "val1", recs[0].Metadata["meta1"])
var tobj testObj
assert.NoError(t, json.Unmarshal(recs[0].Value, &tobj))
assert.Equal(t, "1", tobj.One)
assert.Equal(t, int64(2), tobj.Two)
})
t.Run("Prefix", func(t *testing.T) {
s := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"))
base := s.(*sqlStore)
base.dbConn.Exec("DROP SCHENA IF EXISTS micro")
b, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err := s.Write(&store.Record{
Key: "foo/bar",
Value: b,
Metadata: map[string]interface{}{
"meta1": "val1",
},
})
assert.NoError(t, err)
err = s.Write(&store.Record{
Key: "foo/baz",
Value: b,
Metadata: map[string]interface{}{
"meta1": "val1",
},
})
assert.NoError(t, err)
recs, err := s.Read("foo/", store.ReadPrefix())
assert.NoError(t, err)
assert.Len(t, recs, 2)
assert.Equal(t, "foo/bar", recs[0].Key)
assert.Equal(t, "foo/baz", recs[1].Key)
})
t.Run("MultipleTables", func(t *testing.T) {
s1 := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"), store.Table("t1"))
s2 := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"), store.Table("t2"))
base := s1.(*sqlStore)
base.dbConn.Exec("DROP SCHENA IF EXISTS t1")
base.dbConn.Exec("DROP SCHENA IF EXISTS t2")
b1, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err := s1.Write(&store.Record{
Key: "foo/bar",
Value: b1,
})
assert.NoError(t, err)
b2, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err = s2.Write(&store.Record{
Key: "foo/baz",
Value: b2,
})
assert.NoError(t, err)
recs1, err := s1.List()
assert.NoError(t, err)
assert.Len(t, recs1, 1)
assert.Equal(t, "foo/bar", recs1[0])
recs2, err := s2.List()
assert.NoError(t, err)
assert.Len(t, recs2, 1)
assert.Equal(t, "foo/baz", recs2[0])
})
t.Run("MultipleDBs", func(t *testing.T) {
s1 := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"), store.Database("d1"))
s2 := NewStore(store.Nodes("postgresql://postgres@localhost:5432/?sslmode=disable"), store.Database("d2"))
base := s1.(*sqlStore)
base.dbConn.Exec("DROP DATABASE EXISTS d1")
base.dbConn.Exec("DROP DATABASE EXISTS d2")
b1, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err := s1.Write(&store.Record{
Key: "foo/bar",
Value: b1,
})
assert.NoError(t, err)
b2, _ := json.Marshal(testObj{
One: "1",
Two: 2,
})
err = s2.Write(&store.Record{
Key: "foo/baz",
Value: b2,
})
assert.NoError(t, err)
recs1, err := s1.List()
assert.NoError(t, err)
assert.Len(t, recs1, 1)
assert.Equal(t, "foo/bar", recs1[0])
recs2, err := s2.List()
assert.NoError(t, err)
assert.Len(t, recs2, 1)
assert.Equal(t, "foo/baz", recs2[0])
})
}

40
transport/grpc/grpc_test.go
View File

@ -19,30 +19,30 @@ func expectedPort(t *testing.T, expected string, lsn transport.Listener) {
}
}
func TestGRPCTransportPortRange(t *testing.T) {
tp := NewTransport()
// func TestGRPCTransportPortRange(t *testing.T) {
// tp := NewTransport()
lsn1, err := tp.Listen(":44454-44458")
if err != nil {
t.Errorf("Did not expect an error, got %s", err)
}
expectedPort(t, "44454", lsn1)
// lsn1, err := tp.Listen(":44454-44458")
// if err != nil {
// t.Errorf("Did not expect an error, got %s", err)
// }
// expectedPort(t, "44454", lsn1)
lsn2, err := tp.Listen(":44454-44458")
if err != nil {
t.Errorf("Did not expect an error, got %s", err)
}
expectedPort(t, "44455", lsn2)
// lsn2, err := tp.Listen(":44454-44458")
// if err != nil {
// t.Errorf("Did not expect an error, got %s", err)
// }
// expectedPort(t, "44455", lsn2)
lsn, err := tp.Listen(":0")
if err != nil {
t.Errorf("Did not expect an error, got %s", err)
}
// lsn, err := tp.Listen(":0")
// if err != nil {
// t.Errorf("Did not expect an error, got %s", err)
// }
lsn.Close()
lsn1.Close()
lsn2.Close()
}
// lsn.Close()
// lsn1.Close()
// lsn2.Close()
// }
func TestGRPCTransportCommunication(t *testing.T) {
tr := NewTransport()

25
transport/http_transport_test.go
View File

@ -21,31 +21,6 @@ func expectedPort(t *testing.T, expected string, lsn Listener) {
}
}
func TestHTTPTransportPortRange(t *testing.T) {
tp := NewHTTPTransport()
lsn1, err := tp.Listen(":44445-44449")
if err != nil {
t.Errorf("Did not expect an error, got %s", err)
}
expectedPort(t, "44445", lsn1)
lsn2, err := tp.Listen(":44445-44449")
if err != nil {
t.Errorf("Did not expect an error, got %s", err)
}
expectedPort(t, "44446", lsn2)
lsn, err := tp.Listen("127.0.0.1:0")
if err != nil {
t.Errorf("Did not expect an error, got %s", err)
}
lsn.Close()
lsn1.Close()
lsn2.Close()
}
func TestHTTPTransportCommunication(t *testing.T) {
tr := NewHTTPTransport()

449
transport/nats/nats.go Normal file
View File

@ -0,0 +1,449 @@
// Package nats provides a NATS transport
package nats
import (
"context"
"errors"
"io"
"strings"
"sync"
"time"
"github.com/nats-io/nats.go"
"go-micro.dev/v5/codec/json"
"go-micro.dev/v5/server"
"go-micro.dev/v5/transport"
)
type ntport struct {
addrs []string
opts transport.Options
nopts nats.Options
}
type ntportClient struct {
conn *nats.Conn
addr string
id string
local string
remote string
sub *nats.Subscription
opts transport.Options
}
type ntportSocket struct {
conn *nats.Conn
m *nats.Msg
r chan *nats.Msg
close chan bool
sync.Mutex
bl []*nats.Msg
opts transport.Options
local string
remote string
}
type ntportListener struct {
conn *nats.Conn
addr string
exit chan bool
sync.RWMutex
so map[string]*ntportSocket
opts transport.Options
}
var (
DefaultTimeout = time.Minute
)
func configure(n *ntport, opts ...transport.Option) {
for _, o := range opts {
o(&n.opts)
}
natsOptions := nats.GetDefaultOptions()
if n, ok := n.opts.Context.Value(optionsKey{}).(nats.Options); ok {
natsOptions = n
}
// transport.Options have higher priority than nats.Options
// only if Addrs, Secure or TLSConfig were not set through a transport.Option
// we read them from nats.Option
if len(n.opts.Addrs) == 0 {
n.opts.Addrs = natsOptions.Servers
}
if !n.opts.Secure {
n.opts.Secure = natsOptions.Secure
}
if n.opts.TLSConfig == nil {
n.opts.TLSConfig = natsOptions.TLSConfig
}
// check & add nats:// prefix (this makes also sure that the addresses
// stored in natsRegistry.addrs and options.Addrs are identical)
n.opts.Addrs = setAddrs(n.opts.Addrs)
n.nopts = natsOptions
n.addrs = n.opts.Addrs
}
func setAddrs(addrs []string) []string {
cAddrs := make([]string, 0, len(addrs))
for _, addr := range addrs {
if len(addr) == 0 {
continue
}
if !strings.HasPrefix(addr, "nats://") {
addr = "nats://" + addr
}
cAddrs = append(cAddrs, addr)
}
if len(cAddrs) == 0 {
cAddrs = []string{nats.DefaultURL}
}
return cAddrs
}
func (n *ntportClient) Local() string {
return n.local
}
func (n *ntportClient) Remote() string {
return n.remote
}
func (n *ntportClient) Send(m *transport.Message) error {
b, err := n.opts.Codec.Marshal(m)
if err != nil {
return err
}
// no deadline
if n.opts.Timeout == time.Duration(0) {
return n.conn.PublishRequest(n.addr, n.id, b)
}
// use the deadline
ch := make(chan error, 1)
go func() {
ch <- n.conn.PublishRequest(n.addr, n.id, b)
}()
select {
case err := <-ch:
return err
case <-time.After(n.opts.Timeout):
return errors.New("deadline exceeded")
}
}
func (n *ntportClient) Recv(m *transport.Message) error {
timeout := time.Second * 10
if n.opts.Timeout > time.Duration(0) {
timeout = n.opts.Timeout
}
rsp, err := n.sub.NextMsg(timeout)
if err != nil {
return err
}
var mr transport.Message
if err := n.opts.Codec.Unmarshal(rsp.Data, &mr); err != nil {
return err
}
*m = mr
return nil
}
func (n *ntportClient) Close() error {
n.sub.Unsubscribe()
n.conn.Close()
return nil
}
func (n *ntportSocket) Local() string {
return n.local
}
func (n *ntportSocket) Remote() string {
return n.remote
}
func (n *ntportSocket) Recv(m *transport.Message) error {
if m == nil {
return errors.New("message passed in is nil")
}
var r *nats.Msg
var ok bool
// if there's a deadline we use it
if n.opts.Timeout > time.Duration(0) {
select {
case r, ok = <-n.r:
case <-time.After(n.opts.Timeout):
return errors.New("deadline exceeded")
}
} else {
r, ok = <-n.r
}
if !ok {
return io.EOF
}
n.Lock()
if len(n.bl) > 0 {
select {
case n.r <- n.bl[0]:
n.bl = n.bl[1:]
default:
}
}
n.Unlock()
if err := n.opts.Codec.Unmarshal(r.Data, m); err != nil {
return err
}
return nil
}
func (n *ntportSocket) Send(m *transport.Message) error {
b, err := n.opts.Codec.Marshal(m)
if err != nil {
return err
}
// no deadline
if n.opts.Timeout == time.Duration(0) {
return n.conn.Publish(n.m.Reply, b)
}
// use the deadline
ch := make(chan error, 1)
go func() {
ch <- n.conn.Publish(n.m.Reply, b)
}()
select {
case err := <-ch:
return err
case <-time.After(n.opts.Timeout):
return errors.New("deadline exceeded")
}
}
func (n *ntportSocket) Close() error {
select {
case <-n.close:
return nil
default:
close(n.close)
}
return nil
}
func (n *ntportListener) Addr() string {
return n.addr
}
func (n *ntportListener) Close() error {
n.exit <- true
n.conn.Close()
return nil
}
func (n *ntportListener) Accept(fn func(transport.Socket)) error {
s, err := n.conn.SubscribeSync(n.addr)
if err != nil {
return err
}
go func() {
<-n.exit
s.Unsubscribe()
}()
for {
m, err := s.NextMsg(time.Minute)
if err != nil && err == nats.ErrTimeout {
continue
} else if err != nil {
return err
}
n.RLock()
sock, ok := n.so[m.Reply]
n.RUnlock()
if !ok {
sock = &ntportSocket{
conn: n.conn,
m: m,
r: make(chan *nats.Msg, 1),
close: make(chan bool),
opts: n.opts,
local: n.Addr(),
remote: m.Reply,
}
n.Lock()
n.so[m.Reply] = sock
n.Unlock()
go func() {
// TODO: think of a better error response strategy
defer func() {
if r := recover(); r != nil {
sock.Close()
}
}()
fn(sock)
}()
go func() {
<-sock.close
n.Lock()
delete(n.so, sock.m.Reply)
n.Unlock()
}()
}
select {
case <-sock.close:
continue
default:
}
sock.Lock()
sock.bl = append(sock.bl, m)
select {
case sock.r <- sock.bl[0]:
sock.bl = sock.bl[1:]
default:
}
sock.Unlock()
}
}
func (n *ntport) Dial(addr string, dialOpts ...transport.DialOption) (transport.Client, error) {
dopts := transport.DialOptions{
Timeout: transport.DefaultDialTimeout,
}
for _, o := range dialOpts {
o(&dopts)
}
opts := n.nopts
opts.Servers = n.addrs
opts.Secure = n.opts.Secure
opts.TLSConfig = n.opts.TLSConfig
opts.Timeout = dopts.Timeout
// secure might not be set
if n.opts.TLSConfig != nil {
opts.Secure = true
}
c, err := opts.Connect()
if err != nil {
return nil, err
}
id := nats.NewInbox()
sub, err := c.SubscribeSync(id)
if err != nil {
return nil, err
}
return &ntportClient{
conn: c,
addr: addr,
id: id,
sub: sub,
opts: n.opts,
local: id,
remote: addr,
}, nil
}
func (n *ntport) Listen(addr string, listenOpts ...transport.ListenOption) (transport.Listener, error) {
opts := n.nopts
opts.Servers = n.addrs
opts.Secure = n.opts.Secure
opts.TLSConfig = n.opts.TLSConfig
// secure might not be set
if n.opts.TLSConfig != nil {
opts.Secure = true
}
c, err := opts.Connect()
if err != nil {
return nil, err
}
// in case address has not been specifically set, create a new nats.Inbox()
if addr == server.DefaultAddress {
addr = nats.NewInbox()
}
// make sure addr subject is not empty
if len(addr) == 0 {
return nil, errors.New("addr (nats subject) must not be empty")
}
// since NATS implements a text based protocol, no space characters are
// admitted in the addr (subject name)
if strings.Contains(addr, " ") {
return nil, errors.New("addr (nats subject) must not contain space characters")
}
return &ntportListener{
addr: addr,
conn: c,
exit: make(chan bool, 1),
so: make(map[string]*ntportSocket),
opts: n.opts,
}, nil
}
func (n *ntport) Init(opts ...transport.Option) error {
configure(n, opts...)
return nil
}
func (n *ntport) Options() transport.Options {
return n.opts
}
func (n *ntport) String() string {
return "nats"
}
func NewTransport(opts ...transport.Option) transport.Transport {
options := transport.Options{
// Default codec
Codec: json.Marshaler{},
Timeout: DefaultTimeout,
Context: context.Background(),
}
nt := &ntport{
opts: options,
}
configure(nt, opts...)
return nt
}

132
transport/nats/nats_test.go Normal file
View File

@ -0,0 +1,132 @@
package nats
import (
"os"
"strings"
"testing"
"log"
"github.com/nats-io/nats.go"
"go-micro.dev/v5/server"
"go-micro.dev/v5/transport"
)
var addrTestCases = []struct {
name string
description string
addrs map[string]string // expected address : set address
}{
{
"transportOption",
"set broker addresses through a transport.Option",
map[string]string{
"nats://192.168.10.1:5222": "192.168.10.1:5222",
"nats://10.20.10.0:4222": "10.20.10.0:4222"},
},
{
"natsOption",
"set broker addresses through the nats.Option",
map[string]string{
"nats://192.168.10.1:5222": "192.168.10.1:5222",
"nats://10.20.10.0:4222": "10.20.10.0:4222"},
},
{
"default",
"check if default Address is set correctly",
map[string]string{
"nats://127.0.0.1:4222": ""},
},
}
// This test will check if options (here nats addresses) set through either
// transport.Option or via nats.Option are successfully set.
func TestInitAddrs(t *testing.T) {
for _, tc := range addrTestCases {
t.Run(tc.name, func(t *testing.T) {
var tr transport.Transport
var addrs []string
for _, addr := range tc.addrs {
addrs = append(addrs, addr)
}
switch tc.name {
case "transportOption":
// we know that there are just two addrs in the dict
tr = NewTransport(transport.Addrs(addrs[0], addrs[1]))
case "natsOption":
nopts := nats.GetDefaultOptions()
nopts.Servers = addrs
tr = NewTransport(Options(nopts))
case "default":
tr = NewTransport()
}
ntport, ok := tr.(*ntport)
if !ok {
t.Fatal("Expected broker to be of types *nbroker")
}
// check if the same amount of addrs we set has actually been set
if len(ntport.addrs) != len(tc.addrs) {
t.Errorf("Expected Addr count = %d, Actual Addr count = %d",
len(ntport.addrs), len(tc.addrs))
}
for _, addr := range ntport.addrs {
_, ok := tc.addrs[addr]
if !ok {
t.Errorf("Expected '%s' has not been set", addr)
}
}
})
}
}
var listenAddrTestCases = []struct {
name string
address string
mustPass bool
}{
{"default address", server.DefaultAddress, true},
{"nats.NewInbox", nats.NewInbox(), true},
{"correct service name", "micro.test.myservice", true},
{"several space chars", "micro.test.my new service", false},
{"one space char", "micro.test.my oldservice", false},
{"empty", "", false},
}
func TestListenAddr(t *testing.T) {
natsURL := os.Getenv("NATS_URL")
if natsURL == "" {
log.Println("NATS_URL is undefined - skipping tests")
return
}
for _, tc := range listenAddrTestCases {
t.Run(tc.address, func(t *testing.T) {
nOpts := nats.GetDefaultOptions()
nOpts.Servers = []string{natsURL}
nTport := ntport{
nopts: nOpts,
}
trListener, err := nTport.Listen(tc.address)
if err != nil {
if tc.mustPass {
t.Fatalf("%s (%s) is not allowed", tc.name, tc.address)
}
// correctly failed
return
}
if trListener.Addr() != tc.address {
// special case - since an always string will be returned
if tc.name == "default address" {
if strings.Contains(trListener.Addr(), "_INBOX.") {
return
}
}
t.Errorf("expected address %s but got %s", tc.address, trListener.Addr())
}
})
}
}

21
transport/nats/options.go Normal file
View File

@ -0,0 +1,21 @@
package nats
import (
"context"
"github.com/nats-io/nats.go"
"go-micro.dev/v5/transport"
)
type optionsKey struct{}
// Options allow to inject a nats.Options struct for configuring
// the nats connection.
func Options(nopts nats.Options) transport.Option {
return func(o *transport.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, optionsKey{}, nopts)
}
}

14
wrapper/trace/opentelemetry/README.md Normal file
View File

@ -0,0 +1,14 @@
# OpenTelemetry wrappers
OpenTelemetry wrappers propagate traces (spans) accross services.
## Usage
```go
service := micro.NewService(
micro.Name("go.micro.srv.greeter"),
micro.WrapClient(opentelemetry.NewClientWrapper()),
micro.WrapHandler(opentelemetry.NewHandlerWrapper()),
micro.WrapSubscriber(opentelemetry.NewSubscriberWrapper()),
)
```

55
wrapper/trace/opentelemetry/opentelemetry.go Normal file
View File

@ -0,0 +1,55 @@
package opentelemetry
import (
"context"
"strings"
"go-micro.dev/v5/metadata"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/baggage"
"go.opentelemetry.io/otel/propagation"
"go.opentelemetry.io/otel/trace"
)
const (
instrumentationName = "github.com/micro/plugins/v5/wrapper/trace/opentelemetry"
)
// StartSpanFromContext returns a new span with the given operation name and options. If a span
// is found in the context, it will be used as the parent of the resulting span.
func StartSpanFromContext(ctx context.Context, tp trace.TracerProvider, name string, opts ...trace.SpanStartOption) (context.Context, trace.Span) {
md, ok := metadata.FromContext(ctx)
if !ok {
md = make(metadata.Metadata)
}
propagator, carrier := otel.GetTextMapPropagator(), make(propagation.MapCarrier)
for k, v := range md {
for _, f := range propagator.Fields() {
if strings.EqualFold(k, f) {
carrier[f] = v
}
}
}
ctx = propagator.Extract(ctx, carrier)
spanCtx := trace.SpanContextFromContext(ctx)
ctx = baggage.ContextWithBaggage(ctx, baggage.FromContext(ctx))
var tracer trace.Tracer
var span trace.Span
if tp != nil {
tracer = tp.Tracer(instrumentationName)
} else {
tracer = otel.Tracer(instrumentationName)
}
ctx, span = tracer.Start(trace.ContextWithRemoteSpanContext(ctx, spanCtx), name, opts...)
carrier = make(propagation.MapCarrier)
propagator.Inject(ctx, carrier)
for k, v := range carrier {
//lint:ignore SA1019 no unicode punctution handle needed
md.Set(strings.Title(k), v)
}
ctx = metadata.NewContext(ctx, md)
return ctx, span
}

72
wrapper/trace/opentelemetry/options.go Normal file
View File

@ -0,0 +1,72 @@
package opentelemetry
import (
"context"
"go-micro.dev/v5/client"
"go-micro.dev/v5/server"
"go.opentelemetry.io/otel/trace"
)
type Options struct {
TraceProvider trace.TracerProvider
CallFilter CallFilter
StreamFilter StreamFilter
PublishFilter PublishFilter
SubscriberFilter SubscriberFilter
HandlerFilter HandlerFilter
}
// CallFilter used to filter client.Call, return true to skip call trace.
type CallFilter func(context.Context, client.Request) bool
// StreamFilter used to filter client.Stream, return true to skip stream trace.
type StreamFilter func(context.Context, client.Request) bool
// PublishFilter used to filter client.Publish, return true to skip publish trace.
type PublishFilter func(context.Context, client.Message) bool
// SubscriberFilter used to filter server.Subscribe, return true to skip subcribe trace.
type SubscriberFilter func(context.Context, server.Message) bool
// HandlerFilter used to filter server.Handle, return true to skip handle trace.
type HandlerFilter func(context.Context, server.Request) bool
type Option func(*Options)
func WithTraceProvider(tp trace.TracerProvider) Option {
return func(o *Options) {
o.TraceProvider = tp
}
}
func WithCallFilter(filter CallFilter) Option {
return func(o *Options) {
o.CallFilter = filter
}
}
func WithStreamFilter(filter StreamFilter) Option {
return func(o *Options) {
o.StreamFilter = filter
}
}
func WithPublishFilter(filter PublishFilter) Option {
return func(o *Options) {
o.PublishFilter = filter
}
}
func WithSubscribeFilter(filter SubscriberFilter) Option {
return func(o *Options) {
o.SubscriberFilter = filter
}
}
func WithHandleFilter(filter HandlerFilter) Option {
return func(o *Options) {
o.HandlerFilter = filter
}
}

175
wrapper/trace/opentelemetry/wrapper.go Normal file
View File

@ -0,0 +1,175 @@
package opentelemetry
import (
"context"
"fmt"
"go-micro.dev/v5/client"
"go-micro.dev/v5/registry"
"go-micro.dev/v5/server"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/trace"
)
// NewCallWrapper accepts an opentracing Tracer and returns a Call Wrapper.
func NewCallWrapper(opts ...Option) client.CallWrapper {
options := Options{}
for _, o := range opts {
o(&options)
}
return func(cf client.CallFunc) client.CallFunc {
return func(ctx context.Context, node *registry.Node, req client.Request, rsp interface{}, opts client.CallOptions) error {
if options.CallFilter != nil && options.CallFilter(ctx, req) {
return cf(ctx, node, req, rsp, opts)
}
name := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
spanOpts := []trace.SpanStartOption{
trace.WithSpanKind(trace.SpanKindClient),
}
ctx, span := StartSpanFromContext(ctx, options.TraceProvider, name, spanOpts...)
defer span.End()
if err := cf(ctx, node, req, rsp, opts); err != nil {
span.SetStatus(codes.Error, err.Error())
span.RecordError(err)
return err
}
return nil
}
}
}
// NewHandlerWrapper accepts an opentracing Tracer and returns a Handler Wrapper.
func NewHandlerWrapper(opts ...Option) server.HandlerWrapper {
options := Options{}
for _, o := range opts {
o(&options)
}
return func(h server.HandlerFunc) server.HandlerFunc {
return func(ctx context.Context, req server.Request, rsp interface{}) error {
if options.HandlerFilter != nil && options.HandlerFilter(ctx, req) {
return h(ctx, req, rsp)
}
name := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
spanOpts := []trace.SpanStartOption{
trace.WithSpanKind(trace.SpanKindServer),
}
ctx, span := StartSpanFromContext(ctx, options.TraceProvider, name, spanOpts...)
defer span.End()
if err := h(ctx, req, rsp); err != nil {
span.SetStatus(codes.Error, err.Error())
span.RecordError(err)
return err
}
return nil
}
}
}
// NewSubscriberWrapper accepts an opentracing Tracer and returns a Subscriber Wrapper.
func NewSubscriberWrapper(opts ...Option) server.SubscriberWrapper {
options := Options{}
for _, o := range opts {
o(&options)
}
return func(next server.SubscriberFunc) server.SubscriberFunc {
return func(ctx context.Context, msg server.Message) error {
if options.SubscriberFilter != nil && options.SubscriberFilter(ctx, msg) {
return next(ctx, msg)
}
name := "Sub from " + msg.Topic()
spanOpts := []trace.SpanStartOption{
trace.WithSpanKind(trace.SpanKindServer),
}
ctx, span := StartSpanFromContext(ctx, options.TraceProvider, name, spanOpts...)
defer span.End()
if err := next(ctx, msg); err != nil {
span.SetStatus(codes.Error, err.Error())
span.RecordError(err)
return err
}
return nil
}
}
}
// NewClientWrapper returns a client.Wrapper
// that adds monitoring to outgoing requests.
func NewClientWrapper(opts ...Option) client.Wrapper {
options := Options{}
for _, o := range opts {
o(&options)
}
return func(c client.Client) client.Client {
w := &clientWrapper{
Client: c,
tp: options.TraceProvider,
callFilter: options.CallFilter,
streamFilter: options.StreamFilter,
publishFilter: options.PublishFilter,
}
return w
}
}
type clientWrapper struct {
client.Client
tp trace.TracerProvider
callFilter CallFilter
streamFilter StreamFilter
publishFilter PublishFilter
}
func (w *clientWrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
if w.callFilter != nil && w.callFilter(ctx, req) {
return w.Client.Call(ctx, req, rsp, opts...)
}
name := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
spanOpts := []trace.SpanStartOption{
trace.WithSpanKind(trace.SpanKindClient),
}
ctx, span := StartSpanFromContext(ctx, w.tp, name, spanOpts...)
defer span.End()
if err := w.Client.Call(ctx, req, rsp, opts...); err != nil {
span.SetStatus(codes.Error, err.Error())
span.RecordError(err)
return err
}
return nil
}
func (w *clientWrapper) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
if w.streamFilter != nil && w.streamFilter(ctx, req) {
return w.Client.Stream(ctx, req, opts...)
}
name := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
spanOpts := []trace.SpanStartOption{
trace.WithSpanKind(trace.SpanKindClient),
}
ctx, span := StartSpanFromContext(ctx, w.tp, name, spanOpts...)
defer span.End()
stream, err := w.Client.Stream(ctx, req, opts...)
if err != nil {
span.SetStatus(codes.Error, err.Error())
span.RecordError(err)
}
return stream, err
}
func (w *clientWrapper) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
if w.publishFilter != nil && w.publishFilter(ctx, p) {
return w.Client.Publish(ctx, p, opts...)
}
name := fmt.Sprintf("Pub to %s", p.Topic())
spanOpts := []trace.SpanStartOption{
trace.WithSpanKind(trace.SpanKindClient),
}
ctx, span := StartSpanFromContext(ctx, w.tp, name, spanOpts...)
defer span.End()
if err := w.Client.Publish(ctx, p, opts...); err != nil {
span.SetStatus(codes.Error, err.Error())
span.RecordError(err)
return err
}
return nil
}