Initial QSfera import

Server/vendor/go-micro.dev/v4/store/memory.go

@@ -0,0 +1,301 @@
+package store
+
+import (
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/patrickmn/go-cache"
+	"github.com/pkg/errors"
+)
+
+// NewMemoryStore returns a memory store.
+func NewMemoryStore(opts ...Option) Store {
+	s := &memoryStore{
+		options: Options{
+			Database: "micro",
+			Table:    "micro",
+		},
+		store: cache.New(cache.NoExpiration, 5*time.Minute),
+	}
+	for _, o := range opts {
+		o(&s.options)
+	}
+	return s
+}
+
+type memoryStore struct {
+	options Options
+
+	store *cache.Cache
+}
+
+type storeRecord struct {
+	expiresAt time.Time
+	metadata  map[string]interface{}
+	key       string
+	value     []byte
+}
+
+func (m *memoryStore) key(prefix, key string) string {
+	return filepath.Join(prefix, key)
+}
+
+func (m *memoryStore) prefix(database, table string) string {
+	if len(database) == 0 {
+		database = m.options.Database
+	}
+	if len(table) == 0 {
+		table = m.options.Table
+	}
+	return filepath.Join(database, table)
+}
+
+func (m *memoryStore) get(prefix, key string) (*Record, error) {
+	key = m.key(prefix, key)
+
+	var storedRecord *storeRecord
+	r, found := m.store.Get(key)
+	if !found {
+		return nil, ErrNotFound
+	}
+
+	storedRecord, ok := r.(*storeRecord)
+	if !ok {
+		return nil, errors.New("Retrieved a non *storeRecord from the cache")
+	}
+
+	// Copy the record on the way out
+	newRecord := &Record{}
+	newRecord.Key = strings.TrimPrefix(storedRecord.key, prefix+"/")
+	newRecord.Value = make([]byte, len(storedRecord.value))
+	newRecord.Metadata = make(map[string]interface{})
+
+	// copy the value into the new record
+	copy(newRecord.Value, storedRecord.value)
+
+	// check if we need to set the expiry
+	if !storedRecord.expiresAt.IsZero() {
+		newRecord.Expiry = time.Until(storedRecord.expiresAt)
+	}
+
+	// copy in the metadata
+	for k, v := range storedRecord.metadata {
+		newRecord.Metadata[k] = v
+	}
+
+	return newRecord, nil
+}
+
+func (m *memoryStore) set(prefix string, r *Record) {
+	key := m.key(prefix, r.Key)
+
+	// copy the incoming record and then
+	// convert the expiry in to a hard timestamp
+	i := &storeRecord{}
+	i.key = r.Key
+	i.value = make([]byte, len(r.Value))
+	i.metadata = make(map[string]interface{})
+
+	// copy the the value
+	copy(i.value, r.Value)
+
+	// set the expiry
+	if r.Expiry != 0 {
+		i.expiresAt = time.Now().Add(r.Expiry)
+	}
+
+	// set the metadata
+	for k, v := range r.Metadata {
+		i.metadata[k] = v
+	}
+
+	m.store.Set(key, i, r.Expiry)
+}
+
+func (m *memoryStore) delete(prefix, key string) {
+	key = m.key(prefix, key)
+	m.store.Delete(key)
+}
+
+func (m *memoryStore) list(prefix string, limit, offset uint) []string {
+	allItems := m.store.Items()
+	foundKeys := make([]string, 0, len(allItems))
+
+	for k := range allItems {
+		if !strings.HasPrefix(k, prefix+"/") {
+			continue
+		}
+		foundKeys = append(foundKeys, strings.TrimPrefix(k, prefix+"/"))
+	}
+
+	if limit != 0 || offset != 0 {
+		sort.Slice(foundKeys, func(i, j int) bool { return foundKeys[i] < foundKeys[j] })
+		min := func(i, j uint) uint {
+			if i < j {
+				return i
+			}
+			return j
+		}
+		return foundKeys[offset:min(limit, uint(len(foundKeys)))]
+	}
+
+	return foundKeys
+}
+
+func (m *memoryStore) Close() error {
+	m.store.Flush()
+	return nil
+}
+
+func (m *memoryStore) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&m.options)
+	}
+	return nil
+}
+
+func (m *memoryStore) String() string {
+	return "memory"
+}
+
+func (m *memoryStore) Read(key string, opts ...ReadOption) ([]*Record, error) {
+	readOpts := ReadOptions{}
+	for _, o := range opts {
+		o(&readOpts)
+	}
+
+	prefix := m.prefix(readOpts.Database, readOpts.Table)
+
+	var keys []string
+
+	// Handle Prefix / suffix
+	if readOpts.Prefix || readOpts.Suffix {
+		k := m.list(prefix, 0, 0)
+		limit := int(readOpts.Limit)
+		offset := int(readOpts.Offset)
+
+		if limit > len(k) {
+			limit = len(k)
+		}
+
+		if offset > len(k) {
+			offset = len(k)
+		}
+
+		for i := offset; i < limit; i++ {
+			kk := k[i]
+
+			if readOpts.Prefix && !strings.HasPrefix(kk, key) {
+				continue
+			}
+
+			if readOpts.Suffix && !strings.HasSuffix(kk, key) {
+				continue
+			}
+
+			keys = append(keys, kk)
+		}
+	} else {
+		keys = []string{key}
+	}
+
+	var results []*Record
+
+	for _, k := range keys {
+		r, err := m.get(prefix, k)
+		if err != nil {
+			return results, err
+		}
+		results = append(results, r)
+	}
+
+	return results, nil
+}
+
+func (m *memoryStore) Write(r *Record, opts ...WriteOption) error {
+	writeOpts := WriteOptions{}
+	for _, o := range opts {
+		o(&writeOpts)
+	}
+
+	prefix := m.prefix(writeOpts.Database, writeOpts.Table)
+
+	if len(opts) > 0 {
+		// Copy the record before applying options, or the incoming record will be mutated
+		newRecord := Record{}
+		newRecord.Key = r.Key
+		newRecord.Value = make([]byte, len(r.Value))
+		newRecord.Metadata = make(map[string]interface{})
+		copy(newRecord.Value, r.Value)
+		newRecord.Expiry = r.Expiry
+
+		if !writeOpts.Expiry.IsZero() {
+			newRecord.Expiry = time.Until(writeOpts.Expiry)
+		}
+		if writeOpts.TTL != 0 {
+			newRecord.Expiry = writeOpts.TTL
+		}
+
+		for k, v := range r.Metadata {
+			newRecord.Metadata[k] = v
+		}
+
+		m.set(prefix, &newRecord)
+		return nil
+	}
+
+	// set
+	m.set(prefix, r)
+
+	return nil
+}
+
+func (m *memoryStore) Delete(key string, opts ...DeleteOption) error {
+	deleteOptions := DeleteOptions{}
+	for _, o := range opts {
+		o(&deleteOptions)
+	}
+
+	prefix := m.prefix(deleteOptions.Database, deleteOptions.Table)
+	m.delete(prefix, key)
+	return nil
+}
+
+func (m *memoryStore) Options() Options {
+	return m.options
+}
+
+func (m *memoryStore) List(opts ...ListOption) ([]string, error) {
+	listOptions := ListOptions{}
+
+	for _, o := range opts {
+		o(&listOptions)
+	}
+
+	prefix := m.prefix(listOptions.Database, listOptions.Table)
+	keys := m.list(prefix, listOptions.Limit, listOptions.Offset)
+
+	if len(listOptions.Prefix) > 0 {
+		var prefixKeys []string
+		for _, k := range keys {
+			if strings.HasPrefix(k, listOptions.Prefix) {
+				prefixKeys = append(prefixKeys, k)
+			}
+		}
+		keys = prefixKeys
+	}
+
+	if len(listOptions.Suffix) > 0 {
+		var suffixKeys []string
+		for _, k := range keys {
+			if strings.HasSuffix(k, listOptions.Suffix) {
+				suffixKeys = append(suffixKeys, k)
+			}
+		}
+		keys = suffixKeys
+	}
+
+	return keys, nil
+}

Server/vendor/go-micro.dev/v4/store/noop.go

@@ -0,0 +1,39 @@
+package store
+
+type noopStore struct{}
+
+func (n *noopStore) Init(opts ...Option) error {
+	return nil
+}
+
+func (n *noopStore) Options() Options {
+	return Options{}
+}
+
+func (n *noopStore) String() string {
+	return "noop"
+}
+
+func (n *noopStore) Read(key string, opts ...ReadOption) ([]*Record, error) {
+	return []*Record{}, nil
+}
+
+func (n *noopStore) Write(r *Record, opts ...WriteOption) error {
+	return nil
+}
+
+func (n *noopStore) Delete(key string, opts ...DeleteOption) error {
+	return nil
+}
+
+func (n *noopStore) List(opts ...ListOption) ([]string, error) {
+	return []string{}, nil
+}
+
+func (n *noopStore) Close() error {
+	return nil
+}
+
+func NewNoopStore(opts ...Option) Store {
+	return new(noopStore)
+}

Server/vendor/go-micro.dev/v4/store/options.go

@@ -0,0 +1,229 @@
+package store
+
+import (
+	"context"
+	"time"
+
+	"go-micro.dev/v4/client"
+	"go-micro.dev/v4/logger"
+)
+
+// Options contains configuration for the Store.
+type Options struct {
+	// Context should contain all implementation specific options, using context.WithValue.
+	Context context.Context
+	// Client to use for RPC
+	Client client.Client
+	// Logger is the underline logger
+	Logger logger.Logger
+	// Database allows multiple isolated stores to be kept in one backend, if supported.
+	Database string
+	// Table is analogous to a table in database backends or a key prefix in KV backends
+	Table 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
+}
+
+// Option sets values in Options.
+type Option func(o *Options)
+
+// 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
+	}
+}
+
+func Table(t string) Option {
+	return func(o *Options) {
+		o.Table = t
+	}
+}
+
+// WithContext sets the stores context, for any extra configuration.
+func WithContext(c context.Context) Option {
+	return func(o *Options) {
+		o.Context = c
+	}
+}
+
+// WithClient sets the stores client to use for RPC.
+func WithClient(c client.Client) Option {
+	return func(o *Options) {
+		o.Client = c
+	}
+}
+
+// WithLogger sets the underline logger.
+func WithLogger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
+// ReadOptions configures an individual Read operation.
+type ReadOptions struct {
+	Database, Table string
+	// Prefix returns all records that are prefixed with key
+	Prefix bool
+	// Suffix returns all records that have the suffix key
+	Suffix bool
+	// Limit limits the number of returned records
+	Limit uint
+	// Offset when combined with Limit supports pagination
+	Offset uint
+}
+
+// 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
+	}
+}
+
+// ReadPrefix returns all records that are prefixed with key.
+func ReadPrefix() ReadOption {
+	return func(r *ReadOptions) {
+		r.Prefix = true
+	}
+}
+
+// ReadSuffix returns all records that have the suffix key.
+func ReadSuffix() ReadOption {
+	return func(r *ReadOptions) {
+		r.Suffix = true
+	}
+}
+
+// ReadLimit limits the number of responses to l.
+func ReadLimit(l uint) ReadOption {
+	return func(r *ReadOptions) {
+		r.Limit = l
+	}
+}
+
+// ReadOffset starts returning responses from o. Use in conjunction with Limit for pagination.
+func ReadOffset(o uint) ReadOption {
+	return func(r *ReadOptions) {
+		r.Offset = o
+	}
+}
+
+// WriteOptions configures an individual Write operation
+// If Expiry and TTL are set TTL takes precedence.
+type WriteOptions struct {
+	// Expiry is the time the record expires
+	Expiry          time.Time
+	Database, Table string
+	// TTL is the time until the record expires
+	TTL time.Duration
+}
+
+// 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
+	}
+}
+
+// WriteExpiry is the time the record expires.
+func WriteExpiry(t time.Time) WriteOption {
+	return func(w *WriteOptions) {
+		w.Expiry = t
+	}
+}
+
+// WriteTTL is the time the record expires.
+func WriteTTL(d time.Duration) WriteOption {
+	return func(w *WriteOptions) {
+		w.TTL = d
+	}
+}
+
+// DeleteOptions configures an individual Delete operation.
+type DeleteOptions struct {
+	Database, Table string
+}
+
+// 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
+	}
+}
+
+// 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
+}
+
+// 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
+	}
+}

Server/vendor/go-micro.dev/v4/store/store.go

@@ -0,0 +1,51 @@
+// Package store is an interface for distributed data storage.
+// The design document is located at https://github.com/micro/development/blob/master/design/store.md
+package store
+
+import (
+	"errors"
+	"time"
+)
+
+var (
+	// ErrNotFound is returned when a key doesn't exist.
+	ErrNotFound = errors.New("not found")
+	// DefaultStore is the memory store.
+	DefaultStore Store = NewStore()
+)
+
+// Store is a data storage interface.
+type Store interface {
+	// 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.
+	Init(...Option) error
+	// Options allows you to view the current options.
+	Options() Options
+	// Read takes a single key name and optional ReadOptions. It returns matching []*Record or an error.
+	Read(key string, opts ...ReadOption) ([]*Record, error)
+	// Write() writes a record to the store, and returns an error if the record was not written.
+	Write(r *Record, opts ...WriteOption) error
+	// Delete removes the record with the corresponding key from the store.
+	Delete(key string, opts ...DeleteOption) error
+	// List returns any keys that match, or an empty list with no error if none matched.
+	List(opts ...ListOption) ([]string, error)
+	// Close the store
+	Close() error
+	// String returns the name of the implementation.
+	String() string
+}
+
+// Record is an item stored or retrieved from a Store.
+type Record struct {
+	// Any associated metadata for indexing
+	Metadata map[string]interface{} `json:"metadata"`
+	// The key to store the record
+	Key string `json:"key"`
+	// The value within the record
+	Value []byte `json:"value"`
+	// Time to expire a record: TODO: change to timestamp
+	Expiry time.Duration `json:"expiry,omitempty"`
+}
+
+func NewStore(opts ...Option) Store {
+	return NewMemoryStore(opts...)
+}