Asim Aslam
c7657f73f4
goreleaser / goreleaser (push) Has been cancelled
* test(harness): read agent plan from the scoped store
The store-scoping change moved an agent's plan from the default table
key agent/{name}/plan to its own table (database "agent", table {name},
key "plan"). The plan-delegate harness tests still read the old key and
failed with 'not found'; read through store.Scope(mem, "agent", name)
like the agent does.
* docs: orient agents-first across README, landing, and docs overview
Lead with agents (then services and flows), surface MCP + A2A as the
interop story, and frame agents as services. Landing hero and feature
grid reordered agents-first with an A2A gateway card.
* v6: module path go-micro.dev/v6, TLS secure by default, NewService
Cut v6. Three breaking changes, bundled so the major bump is paid once:
- Module path go-micro.dev/v5 -> go-micro.dev/v6 across all imports + go.mod.
- TLS verification on by default (was off). MICRO_TLS_SECURE removed;
MICRO_TLS_INSECURE=true opts out for self-signed/dev.
- micro.NewService(name, opts...) is the canonical service constructor,
symmetric with NewAgent/NewFlow; micro.New kept as a deprecated alias;
the old name-less NewService(opts...) removed. Generators emit NewService.
Also ports the JWT auth token provider in-module (go-micro.dev/v6/auth/jwt/token
on golang-jwt/jwt/v5), dropping the v5-pinned github.com/micro/plugins/v5/auth/jwt
and the deprecated dgrijalva/jwt-go.
Docs/README/landing updated to v6 and @latest; v5->v6 migration guide added;
CHANGELOG cut as [6.0.0]. Blog posts left at their historical versions.
---------
Co-authored-by: Claude <noreply@anthropic.com>
124 lines
2.1 KiB
Go
124 lines
2.1 KiB
Go
package selector
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
"go-micro.dev/v6/registry"
|
|
"go-micro.dev/v6/registry/cache"
|
|
)
|
|
|
|
type registrySelector struct {
|
|
so Options
|
|
rc cache.Cache
|
|
mu sync.RWMutex
|
|
}
|
|
|
|
func (c *registrySelector) newCache() cache.Cache {
|
|
opts := make([]cache.Option, 0, 1)
|
|
|
|
if c.so.Context != nil {
|
|
if t, ok := c.so.Context.Value("selector_ttl").(time.Duration); ok {
|
|
opts = append(opts, cache.WithTTL(t))
|
|
}
|
|
}
|
|
|
|
return cache.New(c.so.Registry, opts...)
|
|
}
|
|
|
|
func (c *registrySelector) Init(opts ...Option) error {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
|
|
for _, o := range opts {
|
|
o(&c.so)
|
|
}
|
|
|
|
c.rc.Stop()
|
|
c.rc = c.newCache()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *registrySelector) Options() Options {
|
|
return c.so
|
|
}
|
|
|
|
func (c *registrySelector) Select(service string, opts ...SelectOption) (Next, error) {
|
|
c.mu.RLock()
|
|
defer c.mu.RUnlock()
|
|
|
|
sopts := SelectOptions{
|
|
Strategy: c.so.Strategy,
|
|
}
|
|
|
|
for _, opt := range opts {
|
|
opt(&sopts)
|
|
}
|
|
|
|
// get the service
|
|
// try the cache first
|
|
// if that fails go directly to the registry
|
|
services, err := c.rc.GetService(service)
|
|
if err != nil {
|
|
if errors.Is(err, registry.ErrNotFound) {
|
|
return nil, ErrNotFound
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
|
|
// apply the filters
|
|
for _, filter := range sopts.Filters {
|
|
services = filter(services)
|
|
}
|
|
|
|
// if there's nothing left, return
|
|
if len(services) == 0 {
|
|
return nil, ErrNoneAvailable
|
|
}
|
|
|
|
return sopts.Strategy(services), nil
|
|
}
|
|
|
|
func (c *registrySelector) Mark(service string, node *registry.Node, err error) {
|
|
}
|
|
|
|
func (c *registrySelector) Reset(service string) {
|
|
}
|
|
|
|
// Close stops the watcher and destroys the cache.
|
|
func (c *registrySelector) Close() error {
|
|
c.rc.Stop()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *registrySelector) String() string {
|
|
return "registry"
|
|
}
|
|
|
|
// NewSelector creates a new default selector.
|
|
func NewSelector(opts ...Option) Selector {
|
|
sopts := Options{
|
|
Strategy: Random,
|
|
}
|
|
|
|
for _, opt := range opts {
|
|
opt(&sopts)
|
|
}
|
|
|
|
if sopts.Registry == nil {
|
|
sopts.Registry = registry.DefaultRegistry
|
|
}
|
|
|
|
s := ®istrySelector{
|
|
so: sopts,
|
|
}
|
|
s.rc = s.newCache()
|
|
|
|
return s
|
|
}
|