311 lines
6.9 KiB
Go
311 lines
6.9 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"crypto/tls"
|
|
"time"
|
|
|
|
"github.com/unistack-org/micro/v3/codec"
|
|
"github.com/unistack-org/micro/v3/logger"
|
|
"github.com/unistack-org/micro/v3/metadata"
|
|
"github.com/unistack-org/micro/v3/meter"
|
|
"github.com/unistack-org/micro/v3/tracer"
|
|
)
|
|
|
|
// Options contains configuration for the Store
|
|
type Options struct {
|
|
Name string
|
|
// Nodes contains the addresses or other connection information of the backing storage.
|
|
// For example, an etcd implementation would contain the nodes of the cluster.
|
|
// A SQL implementation could contain one or more connection strings.
|
|
Nodes []string
|
|
// Database allows multiple isolated stores to be kept in one backend, if supported.
|
|
Database string
|
|
// Table is analag for a table in database backends or a key prefix in KV backends
|
|
Table string
|
|
// Codec that used for marshal/unmarshal value
|
|
Codec codec.Codec
|
|
// Logger the logger
|
|
Logger logger.Logger
|
|
// Meter the meter
|
|
Meter meter.Meter
|
|
// Tracer the tacer
|
|
Tracer tracer.Tracer
|
|
// TLSConfig specifies tls.Config for secure
|
|
TLSConfig *tls.Config
|
|
|
|
// Context should contain all implementation specific options, using context.WithValue.
|
|
Context context.Context
|
|
}
|
|
|
|
// NewOptions creates options struct
|
|
func NewOptions(opts ...Option) Options {
|
|
options := Options{
|
|
Logger: logger.DefaultLogger,
|
|
Context: context.Background(),
|
|
Codec: codec.DefaultCodec,
|
|
Tracer: tracer.DefaultTracer,
|
|
Meter: meter.DefaultMeter,
|
|
}
|
|
for _, o := range opts {
|
|
o(&options)
|
|
}
|
|
return options
|
|
}
|
|
|
|
// Option sets values in Options
|
|
type Option func(o *Options)
|
|
|
|
// TLSConfig specifies a *tls.Config
|
|
func TLSConfig(t *tls.Config) Option {
|
|
return func(o *Options) {
|
|
o.TLSConfig = t
|
|
}
|
|
}
|
|
|
|
// Context pass context to store
|
|
func Context(ctx context.Context) Option {
|
|
return func(o *Options) {
|
|
o.Context = ctx
|
|
}
|
|
}
|
|
|
|
// Codec sets the codec
|
|
func Codec(c codec.Codec) Option {
|
|
return func(o *Options) {
|
|
o.Codec = c
|
|
}
|
|
}
|
|
|
|
// Logger sets the logger
|
|
func Logger(l logger.Logger) Option {
|
|
return func(o *Options) {
|
|
o.Logger = l
|
|
}
|
|
}
|
|
|
|
// Meter sets the meter
|
|
func Meter(m meter.Meter) Option {
|
|
return func(o *Options) {
|
|
o.Meter = m
|
|
}
|
|
}
|
|
|
|
// Name the name
|
|
func Name(n string) Option {
|
|
return func(o *Options) {
|
|
o.Name = n
|
|
}
|
|
}
|
|
|
|
// Tracer sets the tracer
|
|
func Tracer(t tracer.Tracer) Option {
|
|
return func(o *Options) {
|
|
o.Tracer = t
|
|
}
|
|
}
|
|
|
|
// Nodes contains the addresses or other connection information of the backing storage.
|
|
// For example, an etcd implementation would contain the nodes of the cluster.
|
|
// A SQL implementation could contain one or more connection strings.
|
|
func Nodes(a ...string) Option {
|
|
return func(o *Options) {
|
|
o.Nodes = a
|
|
}
|
|
}
|
|
|
|
// Database allows multiple isolated stores to be kept in one backend, if supported.
|
|
func Database(db string) Option {
|
|
return func(o *Options) {
|
|
o.Database = db
|
|
}
|
|
}
|
|
|
|
// Table is analag for a table in database backends or a key prefix in KV backends
|
|
func Table(t string) Option {
|
|
return func(o *Options) {
|
|
o.Table = t
|
|
}
|
|
}
|
|
|
|
// NewReadOptions fills ReadOptions struct with opts slice
|
|
func NewReadOptions(opts ...ReadOption) ReadOptions {
|
|
options := ReadOptions{}
|
|
for _, o := range opts {
|
|
o(&options)
|
|
}
|
|
return options
|
|
}
|
|
|
|
// ReadOptions configures an individual Read operation
|
|
type ReadOptions struct {
|
|
Database string
|
|
Table string
|
|
Namespace string
|
|
Context context.Context
|
|
}
|
|
|
|
// ReadOption sets values in ReadOptions
|
|
type ReadOption func(r *ReadOptions)
|
|
|
|
// ReadFrom the database and table
|
|
func ReadFrom(database, table string) ReadOption {
|
|
return func(r *ReadOptions) {
|
|
r.Database = database
|
|
r.Table = table
|
|
}
|
|
}
|
|
|
|
// NewWriteOptions fills WriteOptions struct with opts slice
|
|
func NewWriteOptions(opts ...WriteOption) WriteOptions {
|
|
options := WriteOptions{}
|
|
for _, o := range opts {
|
|
o(&options)
|
|
}
|
|
return options
|
|
}
|
|
|
|
// WriteOptions configures an individual Write operation
|
|
type WriteOptions struct {
|
|
Database string
|
|
Table string
|
|
TTL time.Duration
|
|
Metadata metadata.Metadata
|
|
Namespace string
|
|
Context context.Context
|
|
}
|
|
|
|
// WriteOption sets values in WriteOptions
|
|
type WriteOption func(w *WriteOptions)
|
|
|
|
// WriteTo the database and table
|
|
func WriteTo(database, table string) WriteOption {
|
|
return func(w *WriteOptions) {
|
|
w.Database = database
|
|
w.Table = table
|
|
}
|
|
}
|
|
|
|
// WriteTTL is the time the record expires
|
|
func WriteTTL(d time.Duration) WriteOption {
|
|
return func(w *WriteOptions) {
|
|
w.TTL = d
|
|
}
|
|
}
|
|
|
|
// WriteMetadata add metadata.Metadata
|
|
func WriteMetadata(md metadata.Metadata) WriteOption {
|
|
return func(w *WriteOptions) {
|
|
w.Metadata = metadata.Copy(md)
|
|
}
|
|
}
|
|
|
|
// NewDeleteOptions fills DeleteOptions struct with opts slice
|
|
func NewDeleteOptions(opts ...DeleteOption) DeleteOptions {
|
|
options := DeleteOptions{}
|
|
for _, o := range opts {
|
|
o(&options)
|
|
}
|
|
return options
|
|
}
|
|
|
|
// DeleteOptions configures an individual Delete operation
|
|
type DeleteOptions struct {
|
|
Database string
|
|
Table string
|
|
Namespace string
|
|
Context context.Context
|
|
}
|
|
|
|
// DeleteOption sets values in DeleteOptions
|
|
type DeleteOption func(d *DeleteOptions)
|
|
|
|
// DeleteFrom the database and table
|
|
func DeleteFrom(database, table string) DeleteOption {
|
|
return func(d *DeleteOptions) {
|
|
d.Database = database
|
|
d.Table = table
|
|
}
|
|
}
|
|
|
|
// NewListOptions fills ListOptions struct with opts slice
|
|
func NewListOptions(opts ...ListOption) ListOptions {
|
|
options := ListOptions{}
|
|
for _, o := range opts {
|
|
o(&options)
|
|
}
|
|
return options
|
|
}
|
|
|
|
// ListOptions configures an individual List operation
|
|
type ListOptions struct {
|
|
// List from the following
|
|
Database, Table string
|
|
// Prefix returns all keys that are prefixed with key
|
|
Prefix string
|
|
// Suffix returns all keys that end with key
|
|
Suffix string
|
|
// Limit limits the number of returned keys
|
|
Limit uint
|
|
// Offset when combined with Limit supports pagination
|
|
Offset uint
|
|
Namespace string
|
|
Context context.Context
|
|
}
|
|
|
|
// ListOption sets values in ListOptions
|
|
type ListOption func(l *ListOptions)
|
|
|
|
// ListFrom the database and table
|
|
func ListFrom(database, table string) ListOption {
|
|
return func(l *ListOptions) {
|
|
l.Database = database
|
|
l.Table = table
|
|
}
|
|
}
|
|
|
|
// ListPrefix returns all keys that are prefixed with key
|
|
func ListPrefix(p string) ListOption {
|
|
return func(l *ListOptions) {
|
|
l.Prefix = p
|
|
}
|
|
}
|
|
|
|
// ListSuffix returns all keys that end with key
|
|
func ListSuffix(s string) ListOption {
|
|
return func(l *ListOptions) {
|
|
l.Suffix = s
|
|
}
|
|
}
|
|
|
|
// ListLimit limits the number of returned keys to l
|
|
func ListLimit(l uint) ListOption {
|
|
return func(lo *ListOptions) {
|
|
lo.Limit = l
|
|
}
|
|
}
|
|
|
|
// ListOffset starts returning responses from o. Use in conjunction with Limit for pagination.
|
|
func ListOffset(o uint) ListOption {
|
|
return func(l *ListOptions) {
|
|
l.Offset = o
|
|
}
|
|
}
|
|
|
|
type ExistsOption func(*ExistsOptions)
|
|
|
|
type ExistsOptions struct {
|
|
Namespace string
|
|
Context context.Context
|
|
}
|
|
|
|
func NewExistsOptions(opts ...ExistsOption) ExistsOptions {
|
|
options := ExistsOptions{
|
|
Context: context.Background(),
|
|
}
|
|
for _, o := range opts {
|
|
o(&options)
|
|
}
|
|
return options
|
|
}
|