116 lines
2.5 KiB
Go
Executable File
116 lines
2.5 KiB
Go
Executable File
package minio
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"gitea.inhome.blapointe.com/local/storage/resolve"
|
|
"net/url"
|
|
"sort"
|
|
"strings"
|
|
|
|
minio "github.com/minio/minio-go/v6"
|
|
)
|
|
|
|
type Minio struct {
|
|
db *minio.Client
|
|
ListTimestamps bool
|
|
NoRecursiveList bool
|
|
}
|
|
|
|
func NewMinio(addr, user, pass string) (*Minio, error) {
|
|
url, err := url.Parse(addr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
addr = strings.TrimPrefix(addr, url.Scheme+"://")
|
|
db, err := minio.New(addr, user, pass, url.Scheme == "https")
|
|
return &Minio{db: db}, err
|
|
}
|
|
|
|
func (m *Minio) List(ns []string, limits ...string) ([]string, error) {
|
|
namespace := resolve.Namespace(ns)
|
|
limits = resolve.Limits(limits)
|
|
done := make(chan struct{})
|
|
defer close(done)
|
|
keys := []string{}
|
|
prefix := commonSubstr(limits[:2])
|
|
for resp := range m.db.ListObjects(namespace, prefix, !m.NoRecursiveList, done) {
|
|
if resp.Err != nil {
|
|
return keys, resp.Err
|
|
}
|
|
if resp.Key < limits[0] {
|
|
continue
|
|
} else if resp.Key > limits[1] {
|
|
break
|
|
}
|
|
if m.ListTimestamps {
|
|
resp.Key = fmt.Sprintf("[%d,%q]", resp.LastModified.UnixNano(), resp.Key)
|
|
}
|
|
keys = append(keys, resp.Key)
|
|
}
|
|
return keys, nil
|
|
}
|
|
|
|
func (m *Minio) Get(key string, ns ...string) ([]byte, error) {
|
|
namespace := resolve.Namespace(ns)
|
|
obj, err := m.db.GetObject(namespace, key, minio.GetObjectOptions{})
|
|
if err == nil {
|
|
var stat minio.ObjectInfo
|
|
if stat, err = obj.Stat(); err == nil {
|
|
err = stat.Err
|
|
}
|
|
}
|
|
if isNotExistErr(err) {
|
|
return nil, resolve.ErrNotFound
|
|
} else if err != nil {
|
|
return nil, err
|
|
}
|
|
return ioutil.ReadAll(obj)
|
|
}
|
|
|
|
func (m *Minio) Set(key string, value []byte, ns ...string) error {
|
|
namespace := resolve.Namespace(ns)
|
|
if ok, err := m.db.BucketExists(namespace); err != nil {
|
|
return err
|
|
} else if !ok {
|
|
if err := m.db.MakeBucket(namespace, ""); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
_, err := m.db.PutObject(namespace, key, bytes.NewBuffer(value), int64(len(value)), minio.PutObjectOptions{})
|
|
return err
|
|
}
|
|
|
|
func (m *Minio) Close() error {
|
|
m.db = nil
|
|
return nil
|
|
}
|
|
|
|
func isNotExistErr(err error) bool {
|
|
return err != nil && strings.Contains(err.Error(), "does not exist")
|
|
}
|
|
|
|
func commonSubstr(items []string) string {
|
|
if len(items) == 0 {
|
|
return ""
|
|
} else if len(items) == 1 {
|
|
return items[0]
|
|
}
|
|
sort.Strings(items)
|
|
min := items[0]
|
|
max := items[len(items)-1]
|
|
if len(min) == 0 || len(max) == 0 {
|
|
return ""
|
|
}
|
|
if min[0] != max[0] {
|
|
return ""
|
|
}
|
|
for i := 1; i < len(min) && i < len(max); i++ {
|
|
if min[i] != max[i] {
|
|
return min[:i-1]
|
|
}
|
|
}
|
|
return min
|
|
}
|