wip: 完成 client api 分析

internal/database/cache/cache_lru.go

@@ -0,0 +1,111 @@
+package cache
+
+import (
+	"context"
+	"time"
+
+	"esway/internal/interfaces"
+
+	"github.com/hashicorp/golang-lru/v2/expirable"
+	_ "github.com/hashicorp/golang-lru/v2/expirable"
+)
+
+var _ interfaces.Cacher = (*_lru)(nil)
+
+type _lru struct {
+	client *expirable.LRU[string, *_lru_value]
+}
+
+type _lru_value struct {
+	duration time.Duration
+	last     time.Time
+	bs       []byte
+}
+
+func (l *_lru) Get(ctx context.Context, key string) ([]byte, error) {
+	v, ok := l.client.Get(key)
+	if !ok {
+		return nil, ErrorKeyNotFound
+	}
+
+	if v.duration == 0 {
+		return v.bs, nil
+	}
+
+	if time.Now().Sub(v.last) > v.duration {
+		l.client.Remove(key)
+		return nil, ErrorKeyNotFound
+	}
+
+	return v.bs, nil
+}
+
+func (l *_lru) GetEx(ctx context.Context, key string, duration time.Duration) ([]byte, error) {
+	v, ok := l.client.Get(key)
+	if !ok {
+		return nil, ErrorKeyNotFound
+	}
+
+	if v.duration == 0 {
+		return v.bs, nil
+	}
+
+	now := time.Now()
+
+	if now.Sub(v.last) > v.duration {
+		l.client.Remove(key)
+		return nil, ErrorKeyNotFound
+	}
+
+	l.client.Add(key, &_lru_value{
+		duration: duration,
+		last:     now,
+		bs:       v.bs,
+	})
+
+	return v.bs, nil
+}
+
+func (l *_lru) Set(ctx context.Context, key string, value any) error {
+	bs, err := handleValue(value)
+	if err != nil {
+		return err
+	}
+
+	l.client.Add(key, &_lru_value{
+		duration: 0,
+		last:     time.Now(),
+		bs:       bs,
+	})
+
+	return nil
+}
+
+func (l *_lru) SetEx(ctx context.Context, key string, value any, duration time.Duration) error {
+	bs, err := handleValue(value)
+	if err != nil {
+		return err
+	}
+
+	l.client.Add(key, &_lru_value{
+		duration: duration,
+		last:     time.Now(),
+		bs:       bs,
+	})
+
+	return nil
+}
+
+func (l *_lru) Del(ctx context.Context, keys ...string) error {
+	for _, key := range keys {
+		l.client.Remove(key)
+	}
+
+	return nil
+}
+
+func newLRUCache() (interfaces.Cacher, error) {
+	client := expirable.NewLRU[string, *_lru_value](1024*1024, nil, 0)
+
+	return &_lru{client: client}, nil
+}

internal/database/cache/cache_memory.go

@@ -0,0 +1,75 @@
+package cache
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"esway/internal/interfaces"
+
+	"gitea.com/loveuer/gredis"
+)
+
+var _ interfaces.Cacher = (*_mem)(nil)
+
+type _mem struct {
+	client *gredis.Gredis
+}
+
+func (m *_mem) Get(ctx context.Context, key string) ([]byte, error) {
+	v, err := m.client.Get(key)
+	if err != nil {
+		if errors.Is(err, gredis.ErrKeyNotFound) {
+			return nil, ErrorKeyNotFound
+		}
+
+		return nil, err
+	}
+
+	bs, ok := v.([]byte)
+	if !ok {
+		return nil, fmt.Errorf("invalid value type=%T", v)
+	}
+
+	return bs, nil
+}
+
+func (m *_mem) GetEx(ctx context.Context, key string, duration time.Duration) ([]byte, error) {
+	v, err := m.client.GetEx(key, duration)
+	if err != nil {
+		if errors.Is(err, gredis.ErrKeyNotFound) {
+			return nil, ErrorKeyNotFound
+		}
+
+		return nil, err
+	}
+
+	bs, ok := v.([]byte)
+	if !ok {
+		return nil, fmt.Errorf("invalid value type=%T", v)
+	}
+
+	return bs, nil
+}
+
+func (m *_mem) Set(ctx context.Context, key string, value any) error {
+	bs, err := handleValue(value)
+	if err != nil {
+		return err
+	}
+	return m.client.Set(key, bs)
+}
+
+func (m *_mem) SetEx(ctx context.Context, key string, value any, duration time.Duration) error {
+	bs, err := handleValue(value)
+	if err != nil {
+		return err
+	}
+	return m.client.SetEx(key, bs, duration)
+}
+
+func (m *_mem) Del(ctx context.Context, keys ...string) error {
+	m.client.Delete(keys...)
+	return nil
+}

internal/database/cache/cache_redis.go

@@ -0,0 +1,63 @@
+package cache
+
+import (
+	"context"
+	"errors"
+	"github.com/go-redis/redis/v8"
+	"time"
+)
+
+type _redis struct {
+	client *redis.Client
+}
+
+func (r *_redis) Get(ctx context.Context, key string) ([]byte, error) {
+	result, err := r.client.Get(ctx, key).Result()
+	if err != nil {
+		if errors.Is(err, redis.Nil) {
+			return nil, ErrorKeyNotFound
+		}
+
+		return nil, err
+	}
+
+	return []byte(result), nil
+}
+
+func (r *_redis) GetEx(ctx context.Context, key string, duration time.Duration) ([]byte, error) {
+	result, err := r.client.GetEx(ctx, key, duration).Result()
+	if err != nil {
+		if errors.Is(err, redis.Nil) {
+			return nil, ErrorKeyNotFound
+		}
+
+		return nil, err
+	}
+
+	return []byte(result), nil
+}
+
+func (r *_redis) Set(ctx context.Context, key string, value any) error {
+	bs, err := handleValue(value)
+	if err != nil {
+		return err
+	}
+
+	_, err = r.client.Set(ctx, key, bs, redis.KeepTTL).Result()
+	return err
+}
+
+func (r *_redis) SetEx(ctx context.Context, key string, value any, duration time.Duration) error {
+	bs, err := handleValue(value)
+	if err != nil {
+		return err
+	}
+
+	_, err = r.client.SetEX(ctx, key, bs, duration).Result()
+
+	return err
+}
+
+func (r *_redis) Del(ctx context.Context, keys ...string) error {
+	return r.client.Del(ctx, keys...).Err()
+}

internal/database/cache/client.go

@@ -0,0 +1,37 @@
+package cache
+
+import (
+	"encoding/json"
+
+	"esway/internal/interfaces"
+)
+
+var Client interfaces.Cacher
+
+type encoded_value interface {
+	MarshalBinary() ([]byte, error)
+}
+
+type decoded_value interface {
+	UnmarshalBinary(bs []byte) error
+}
+
+func handleValue(value any) ([]byte, error) {
+	var (
+		bs  []byte
+		err error
+	)
+
+	switch value.(type) {
+	case []byte:
+		return value.([]byte), nil
+	}
+
+	if imp, ok := value.(encoded_value); ok {
+		bs, err = imp.MarshalBinary()
+	} else {
+		bs, err = json.Marshal(value)
+	}
+
+	return bs, err
+}

internal/database/cache/error.go

@@ -0,0 +1,7 @@
+package cache
+
+import "errors"
+
+var (
+	ErrorKeyNotFound = errors.New("key not found")
+)

internal/database/cache/init.go

@@ -0,0 +1,69 @@
+package cache
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+
+	"esway/internal/opt"
+	"esway/internal/tool"
+
+	"gitea.com/loveuer/gredis"
+	"github.com/go-redis/redis/v8"
+)
+
+func Init() error {
+	var err error
+
+	strs := strings.Split(opt.Cfg.Cache.Uri, "::")
+
+	switch strs[0] {
+	case "memory":
+		gc := gredis.NewGredis(1024 * 1024)
+		Client = &_mem{client: gc}
+	case "lru":
+		if Client, err = newLRUCache(); err != nil {
+			return err
+		}
+	case "redis":
+		var (
+			ins *url.URL
+			err error
+		)
+
+		if len(strs) != 2 {
+			return fmt.Errorf("cache.Init: invalid cache uri: %s", opt.Cfg.Cache.Uri)
+		}
+
+		uri := strs[1]
+
+		if !strings.Contains(uri, "://") {
+			uri = fmt.Sprintf("redis://%s", uri)
+		}
+
+		if ins, err = url.Parse(uri); err != nil {
+			return fmt.Errorf("cache.Init: url parse cache uri: %s, err: %s", opt.Cfg.Cache.Uri, err.Error())
+		}
+
+		addr := ins.Host
+		username := ins.User.Username()
+		password, _ := ins.User.Password()
+
+		var rc *redis.Client
+		rc = redis.NewClient(&redis.Options{
+			Addr:     addr,
+			Username: username,
+			Password: password,
+		})
+
+		if err = rc.Ping(tool.Timeout(5)).Err(); err != nil {
+			return fmt.Errorf("cache.Init: redis ping err: %s", err.Error())
+		}
+
+		Client = &_redis{client: rc}
+	default:
+		return fmt.Errorf("cache type %s not support", strs[0])
+	}
+
+	return nil
+}

internal/database/db/client.go

@@ -0,0 +1,52 @@
+package db
+
+import (
+	"context"
+
+	"esway/internal/opt"
+	"esway/internal/tool"
+
+	"gorm.io/gorm"
+)
+
+var Default *Client
+
+type DBType string
+
+const (
+	DBTypeSqlite   = "sqlite"
+	DBTypeMysql    = "mysql"
+	DBTypePostgres = "postgres"
+)
+
+type Client struct {
+	ctx    context.Context
+	cli    *gorm.DB
+	dbType DBType
+}
+
+func (c *Client) Type() DBType {
+	return c.dbType
+}
+
+func (c *Client) Session(ctxs ...context.Context) *gorm.DB {
+	var ctx context.Context
+	if len(ctxs) > 0 && ctxs[0] != nil {
+		ctx = ctxs[0]
+	} else {
+		ctx = tool.Timeout(30)
+	}
+
+	session := c.cli.Session(&gorm.Session{Context: ctx})
+
+	if opt.Cfg.Debug {
+		session = session.Debug()
+	}
+
+	return session
+}
+
+func (c *Client) Close() {
+	d, _ := c.cli.DB()
+	d.Close()
+}

internal/database/db/db_test.go

@@ -0,0 +1,8 @@
+package db
+
+import (
+	"testing"
+)
+
+func TestOpen(t *testing.T) {
+}

internal/database/db/new.go

@@ -0,0 +1,55 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/glebarez/sqlite"
+	"gorm.io/driver/mysql"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+)
+
+func New(ctx context.Context, uri string) (*Client, error) {
+	parts := strings.SplitN(uri, "::", 2)
+
+	if len(parts) != 2 {
+		return nil, fmt.Errorf("db.Init: opt db uri invalid: %s", uri)
+	}
+
+	c := &Client{}
+
+	var (
+		err error
+		dsn = parts[1]
+	)
+
+	switch parts[0] {
+	case "sqlite":
+		c.dbType = DBTypeSqlite
+		c.cli, err = gorm.Open(sqlite.Open(dsn))
+	case "mysql":
+		c.dbType = DBTypeMysql
+		c.cli, err = gorm.Open(mysql.Open(dsn))
+	case "postgres":
+		c.dbType = DBTypePostgres
+		c.cli, err = gorm.Open(postgres.Open(dsn))
+	default:
+		return nil, fmt.Errorf("db type only support: [sqlite, mysql, postgres], unsupported db type: %s", parts[0])
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("db.Init: open %s with dsn:%s, err: %w", parts[0], dsn, err)
+	}
+
+	return c, nil
+}
+
+func Init(ctx context.Context, uri string) (err error) {
+	if Default, err = New(ctx, uri); err != nil {
+		return err
+	}
+
+	return nil
+}

internal/database/es/client.go

@@ -0,0 +1,39 @@
+package es
+
+import (
+	"context"
+	"net/url"
+
+	"esway/internal/tool"
+
+	elastic "github.com/elastic/go-elasticsearch/v7"
+	"github.com/loveuer/esgo2dump/xes/es7"
+	"github.com/loveuer/nf/nft/log"
+)
+
+var Default *elastic.Client
+
+func New(ctx context.Context, uri string) (*elastic.Client, error) {
+	var (
+		err    error
+		client *elastic.Client
+		ins    *url.URL
+	)
+
+	if ins, err = url.Parse(uri); err != nil {
+		return nil, err
+	}
+
+	log.Debug("es.InitClient url parse uri: %s, result: %+v", uri, ins)
+
+	if client, err = es7.NewClient(tool.Timeout(10), ins); err != nil {
+		return nil, err
+	}
+
+	return client, nil
+}
+
+func Init(ctx context.Context, uri string) (err error) {
+	Default, err = New(ctx, uri)
+	return err
+}

internal/database/es/raw.go

@@ -0,0 +1 @@
+package es