diff --git a/README.md b/README.md index 72c75ec..b667bef 100644 --- a/README.md +++ b/README.md @@ -20,3 +20,38 @@ curl http://localhost:8080/set/bucket001/foo # List all list curl http://localhost:8080/list/bucket001/key1?start=0&end=10 ``` + +**modify example data** + +You can modify the tests in the sample program by modifying the file "example/init.yaml". + +The file format is as follows: + +```yaml +# kv data +kv: + bucket-a: # bucket name + key-1: # key + str: value-1 # value + key-2: # key + base64: dW50c2Ri # data in base64 format +# list data +list: + bucket-b: # bucket name + key-1: + - str: value-1 + - str: value-2 +# set data +set: + bucket-c: # bucket name + key-1: + - str: value-1 + - str: value-2 +# sorted-set data +zset: + bucket-d: # bucket name + key-1: + - score: 1660575966082 + str: value + +``` diff --git a/config.yaml b/config.yaml new file mode 100644 index 0000000..a85037b --- /dev/null +++ b/config.yaml @@ -0,0 +1,4 @@ +users: + admin: admin + user1: user1 +port: 8080 \ No newline at end of file diff --git a/core_list.go b/core_list.go index f269c30..7b75a8e 100644 --- a/core_list.go +++ b/core_list.go @@ -2,14 +2,111 @@ package nutshttp import "github.com/xujiajun/nutsdb" -func (c *core) LRange(bucket string, key []byte, begin, offset int) ([][]byte, error) { - var items [][]byte +func (c *core) LRange(bucket string, key string, start, end int) ([]string, error) { + var items []string err := c.db.Update(func(tx *nutsdb.Tx) (err error) { - items, err = tx.LRange(bucket, key, begin, offset) + itemsBytes, err := tx.LRange(bucket, []byte(key), start, end) + if err == nil { + for _, itemByte := range itemsBytes { + items = append(items, string(itemByte)) + } + } return err }) return items, err } + +func (c *core) RPush(bucket, key, value string) error { + err := c.db.Update(func(tx *nutsdb.Tx) error { + err := tx.RPush(bucket, []byte(key), []byte(value)) + return err + }) + return err +} + +func (c *core) LPush(bucket, key, value string) error { + err := c.db.Update(func(tx *nutsdb.Tx) error { + err := tx.LPush(bucket, []byte(key), []byte(value)) + return err + }) + return err +} + +func (c *core) RPop(bucket, key string) (value string, err error) { + err = c.db.Update(func(tx *nutsdb.Tx) error { + resByte, err := tx.RPop(bucket, []byte(key)) + if err == nil { + value = string(resByte) + } + return err + }) + return value, err +} + +func (c *core) LPop(bucket, key string) (value string, err error) { + err = c.db.Update(func(tx *nutsdb.Tx) error { + resByte, err := tx.RPop(bucket, []byte(key)) + if err == nil { + value = string(resByte) + } + return err + }) + return value, err +} + +func (c *core) RPeek(bucket, key string) (value string, err error) { + err = c.db.View(func(tx *nutsdb.Tx) error { + resByte, err := tx.RPeek(bucket, []byte(key)) + if err == nil { + value = string(resByte) + } + return nil + }) + return value, err +} + +func (c *core) LPeek(bucket, key string) (value string, err error) { + err = c.db.View(func(tx *nutsdb.Tx) error { + resByte, err := tx.LPeek(bucket, []byte(key)) + if err == nil { + value = string(resByte) + } + return nil + }) + return value, err +} + +func (c *core) LRem(bucket, key, value string, count int) (num int, err error) { + err = c.db.Update(func(tx *nutsdb.Tx) error { + num, err = tx.LRem(bucket, []byte(key), count, []byte(value)) + return err + }) + return num, err +} + +func (c *core) LSet(bucket, key, value string, index int) (err error) { + err = c.db.Update(func(tx *nutsdb.Tx) error { + err = tx.LSet(bucket, []byte(key), index, []byte(value)) + return err + }) + return err +} + +func (c *core) LTrim(bucket, key string, start, end int) (err error) { + err = c.db.View(func(tx *nutsdb.Tx) error { + err = tx.LTrim(bucket, []byte(key), start, end) + return err + }) + return err +} + +func (c *core) LSize(bucket, key string) (size int, err error) { + err = c.db.View(func(tx *nutsdb.Tx) error { + size, err = tx.LSize(bucket, []byte(key)) + return err + }) + return size, err +} diff --git a/core_string.go b/core_string.go new file mode 100644 index 0000000..f6d2b76 --- /dev/null +++ b/core_string.go @@ -0,0 +1,66 @@ +package nutshttp + +import "github.com/xujiajun/nutsdb" + +// Update handle insert and update operation +func (c *core) Update(bucket string, key string, value string, ttl uint32) error { + err := c.db.Update(func(tx *nutsdb.Tx) error { + err := tx.Put(bucket, []byte(key), []byte(value), ttl) + return err + }) + return err +} + +// Delete handle delete operation +func (c *core) Delete(bucket string, key string) error { + err := c.db.Update(func(tx *nutsdb.Tx) error { + err := tx.Delete(bucket, []byte(key)) + return err + }) + return err +} + +// Get handle get key operation +func (c *core) Get(bucket string, key string) (value string, err error) { + err = c.db.View(func(tx *nutsdb.Tx) error { + entry, err := tx.Get(bucket, []byte(key)) + if err != nil { + return err + } + value = string(entry.Value) + return nil + }) + return value, err +} + +func (c *core) PrefixScan(bucket string, prefix string, offSet int, limNum int) (entries nutsdb.Entries, err error) { + err = c.db.View(func(tx *nutsdb.Tx) error { + entries, _, err = tx.PrefixScan(bucket, []byte(prefix), offSet, limNum) + return err + }) + return entries, err +} + +func (c *core) PrefixSearchScan(bucket, prefix string, reg string, offSet int, limNum int) (entries nutsdb.Entries, err error) { + err = c.db.View(func(tx *nutsdb.Tx) error { + entries, _, err = tx.PrefixSearchScan(bucket, []byte(prefix), reg, offSet, limNum) + return err + }) + return entries, err +} + +func (c *core) RangeScan(bucket string, start string, end string) (entries nutsdb.Entries, err error) { + err = c.db.View(func(tx *nutsdb.Tx) error { + entries, err = tx.RangeScan(bucket, []byte(start), []byte(end)) + return err + }) + return entries, err +} + +func (c *core) GetAll(bucket string) (entries nutsdb.Entries, err error) { + err = c.db.View(func(tx *nutsdb.Tx) error { + entries, err = tx.GetAll(bucket) + return err + }) + return entries, err +} diff --git a/core_zset.go b/core_zset.go new file mode 100644 index 0000000..14100ad --- /dev/null +++ b/core_zset.go @@ -0,0 +1,207 @@ +package nutshttp + +import ( + "github.com/xujiajun/nutsdb" + "github.com/xujiajun/nutsdb/ds/zset" +) + +func (c *core) zPut(bucket string, key []byte, score float64, value []byte) error { + if err := c.db.Update(func(tx *nutsdb.Tx) error { + if err := tx.ZAdd(bucket, key, score, value); err != nil { + return err + } + return nil + }); err != nil { + return err + } + return nil +} + +func (c *core) zCard(bucket string) (num int, err error) { + if err = c.db.View(func(tx *nutsdb.Tx) error { + if num, err = tx.ZCard(bucket); err != nil { + return err + } + return nil + }); err != nil { + return num, err + } + return num, err +} + +func (c *core) zCount(bucket string, start, end float64, options *zset.GetByScoreRangeOptions) (count int, err error) { + if err = c.db.View(func(tx *nutsdb.Tx) error { + if count, err = tx.ZCount(bucket, start, end, options); err != nil { + return err + } + return nil + }); err != nil { + return count, err + } + return count, nil +} + +func (c *core) zGetByKey(bucket, key string) (node *zset.SortedSetNode, err error) { + if err = c.db.View(func(tx *nutsdb.Tx) error { + if node, err = tx.ZGetByKey(bucket, []byte(key)); err != nil { + return err + } + return nil + }); err != nil { + return nil, err + } + return node, err +} + +func (c *core) zMembers(bucket string) (nodes []*zset.SortedSetNode, err error) { + var nodesMap map[string]*zset.SortedSetNode + if err = c.db.View(func(tx *nutsdb.Tx) error { + if nodesMap, err = tx.ZMembers(bucket); err != nil { + return err + } + return nil + }); err != nil { + return nil, err + } + nodes = make([]*zset.SortedSetNode, 0, len(nodesMap)) + for _, node := range nodesMap { + nodes = append(nodes, node) + } + return nodes, nil +} + +func (c *core) zPeekMax(bucket string) (node *zset.SortedSetNode, err error) { + if err = c.db.View(func(tx *nutsdb.Tx) error { + if node, err = tx.ZPeekMax(bucket); err != nil { + return err + } + return nil + }); err != nil { + return nil, err + } + return node, nil +} + +func (c *core) zPeekMin(bucket string) (node *zset.SortedSetNode, err error) { + if err = c.db.View(func(tx *nutsdb.Tx) error { + if node, err = tx.ZPeekMin(bucket); err != nil { + return err + } + return nil + }); err != nil { + return nil, err + } + return node, nil +} + +func (c *core) zPopMax(bucket string) (node *zset.SortedSetNode, err error) { + if err = c.db.Update(func(tx *nutsdb.Tx) error { + if node, err = tx.ZPopMax(bucket); err != nil { + return err + } + return nil + }); err != nil { + return nil, err + } + return node, nil +} + +func (c *core) zPopMin(bucket string) (node *zset.SortedSetNode, err error) { + if err = c.db.Update(func(tx *nutsdb.Tx) error { + if node, err = tx.ZPopMin(bucket); err != nil { + return err + } + return nil + }); err != nil { + return nil, err + } + return node, nil +} + +func (c *core) zRangeByRank(bucket string, start, end int) (nodes []*zset.SortedSetNode, err error) { + if err = c.db.View(func(tx *nutsdb.Tx) error { + if nodes, err = tx.ZRangeByRank(bucket, start, end); err != nil { + return err + } + return nil + }); err != nil { + return nil, err + } + return nodes, nil +} + +func (c *core) zRangeByScore(bucket string, start, end float64, options *zset.GetByScoreRangeOptions) (nodes []*zset.SortedSetNode, err error) { + if err = c.db.View(func(tx *nutsdb.Tx) error { + if nodes, err = tx.ZRangeByScore(bucket, start, end, options); err != nil { + return err + } + return nil + }); err != nil { + return nil, err + } + return nodes, nil +} + +func (c *core) zRank(bucket, key string) (rank int, err error) { + if err = c.db.View(func(tx *nutsdb.Tx) error { + if rank, err = tx.ZRank(bucket, []byte(key)); err != nil { + return err + } + return nil + }); err != nil { + return rank, err + } + return rank, nil + +} + +func (c *core) zRevRank(bucket, key string) (rank int, err error) { + if err = c.db.View(func(tx *nutsdb.Tx) error { + if rank, err = tx.ZRevRank(bucket, []byte(key)); err != nil { + return err + } + return nil + }); err != nil { + return rank, err + } + return rank, nil +} + +func (c *core) zRem(bucket, key string) error { + if err := c.db.Update( + func(tx *nutsdb.Tx) error { + if err := tx.ZRem(bucket, key); err != nil { + return err + } + return nil + }); err != nil { + return err + } + return nil +} + +func (c *core) ZRemRangeByRank(bucket string, start, end int) error { + if err := c.db.Update( + func(tx *nutsdb.Tx) error { + if err := tx.ZRemRangeByRank(bucket, start, end); err != nil { + return err + } + return nil + }); err != nil { + return err + } + return nil +} + +func (c *core) zScore(bucket, key string) (score float64, err error) { + if err = c.db.View( + func(tx *nutsdb.Tx) error { + if score, err = tx.ZScore(bucket, []byte(key)); err != nil { + return err + } + return nil + }); err != nil { + return 0, err + } + return score, nil +} diff --git a/examples/hello.go b/examples/hello.go index 6e52042..f97ea83 100644 --- a/examples/hello.go +++ b/examples/hello.go @@ -23,49 +23,8 @@ func main() { } }() - testDB(db) + // init test data + initData(db) select {} } - -func testDB(db *nutsdb.DB) { - var ( - bucket = "bucket001" - - key = []byte("foo") - value = []byte("bar") - ) - - if err := db.Update(func(tx *nutsdb.Tx) error { - if err := tx.SAdd(bucket, key, value); err != nil { - return err - } - - if err := tx.SAdd(bucket, key, []byte("bar2")); err != nil { - return err - } - - _ = tx.RPush(bucket, []byte("key1"), []byte("value1")) - _ = tx.RPush(bucket, []byte("key1"), []byte("value2")) - - return nil - - }); err != nil { - log.Fatal(err) - } - - if err := db.View(func(tx *nutsdb.Tx) error { - items, err := tx.SMembers(bucket, key) - if err != nil { - return err - } - - for _, item := range items { - log.Printf("item: %s", item) - } - return nil - }); err != nil { - - log.Fatal(err) - } -} diff --git a/examples/init.go b/examples/init.go new file mode 100644 index 0000000..1b3c6c6 --- /dev/null +++ b/examples/init.go @@ -0,0 +1,163 @@ +package main + +import ( + "encoding/base64" + "fmt" + "github.com/xujiajun/nutsdb" + "gopkg.in/yaml.v2" + "os" + "time" +) + +type initValueType struct { + Score float64 `yaml:"score"` + Str string `yaml:"str"` + Base64 string `yaml:"base64"` +} + +type initDataType struct { + Kv map[string]map[string]initValueType `yaml:"kv"` + List map[string]map[string][]initValueType `yaml:"list"` + Set map[string]map[string][]initValueType `yaml:"set"` + ZSet map[string]map[string][]initValueType `yaml:"zset"` +} + +func initData(db *nutsdb.DB) { + bytes, err := os.ReadFile("examples/init.yaml") + if err != nil { + panic(err) + } + var yamlData initDataType + err = yaml.Unmarshal(bytes, &yamlData) + if err != nil { + panic(err) + } + + // init kv data + initKvData(db, &yamlData) + + // init list data + initListData(db, &yamlData) + + // init set data + initSetData(db, &yamlData) + + // init sorted set data + initSortedSetData(db, &yamlData) +} + +func initKvData(db *nutsdb.DB, yamlData *initDataType) { + _ = db.Update(func(tx *nutsdb.Tx) error { + // init data from yaml + for bucket, kv := range yamlData.Kv { + for key, value := range kv { + _ = tx.Put(bucket, []byte(key), getValue(value), 86_400_000) + } + } + // multi value + for i := 0; i < 200; i++ { + _ = tx.Put("kv-bucket", []byte("key"), []byte(fmt.Sprintf("value-%d", i)), 86_400_000) + } + // multi key + for i := 0; i < 200; i++ { + _ = tx.Put("kv-bucket", []byte(fmt.Sprintf("key-%d", i)), []byte("value"), 86_400_000) + } + // multi bucket + for i := 0; i < 200; i++ { + _ = tx.Put(fmt.Sprintf("kv-bucket-%d", i), []byte("key"), []byte("value"), 86_400_000) + } + return nil + }) +} + +func initListData(db *nutsdb.DB, yamlData *initDataType) { + _ = db.Update(func(tx *nutsdb.Tx) error { + // init data from yaml + for bucket, kv := range yamlData.List { + for key, values := range kv { + for _, value := range values { + _ = tx.RPush(bucket, []byte(key), getValue(value)) + } + } + } + // multi value + for i := 0; i < 200; i++ { + _ = tx.RPush("list-bucket", []byte("key"), []byte(fmt.Sprintf("value-%d", i))) + } + // multi key + for i := 0; i < 200; i++ { + _ = tx.RPush("list-bucket", []byte(fmt.Sprintf("key-%d", i)), []byte("value")) + } + // multi bucket + for i := 0; i < 200; i++ { + _ = tx.RPush(fmt.Sprintf("list-bucket-%d", i), []byte("key"), []byte("value")) + } + return nil + }) +} + +func initSetData(db *nutsdb.DB, yamlData *initDataType) { + _ = db.Update(func(tx *nutsdb.Tx) error { + // init data from yaml + for bucket, kv := range yamlData.Set { + for key, values := range kv { + for _, value := range values { + _ = tx.SAdd(bucket, []byte(key), getValue(value)) + } + } + } + // multi value + for i := 0; i < 200; i++ { + _ = tx.SAdd("set-bucket", []byte("key"), []byte(fmt.Sprintf("value-%d", i))) + } + // multi key + for i := 0; i < 200; i++ { + _ = tx.SAdd("set-bucket", []byte(fmt.Sprintf("key-%d", i)), []byte("value")) + } + // multi bucket + for i := 0; i < 200; i++ { + _ = tx.SAdd(fmt.Sprintf("set-bucket-%d", i), []byte("key"), []byte("value")) + } + return nil + }) +} + +func initSortedSetData(db *nutsdb.DB, yamlData *initDataType) { + _ = db.Update(func(tx *nutsdb.Tx) error { + // init data from yaml + for bucket, kv := range yamlData.ZSet { + for key, values := range kv { + for _, value := range values { + _ = tx.ZAdd(bucket, []byte(key), value.Score, getValue(value)) + } + } + } + timestamp := float64(time.Now().Unix()) + // multi value + for i := 0; i < 200; i++ { + _ = tx.ZAdd("sorted-set-bucket", []byte("key"), timestamp+float64(i), []byte(fmt.Sprintf("value-%d", i))) + } + // multi key + for i := 0; i < 200; i++ { + _ = tx.ZAdd("sorted-set-bucket", []byte(fmt.Sprintf("key-%d", i)), timestamp+float64(i), []byte("value")) + } + // multi bucket + for i := 0; i < 200; i++ { + _ = tx.ZAdd(fmt.Sprintf("sorted-set-bucket-%d", i), []byte("key"), timestamp+float64(i), []byte("value")) + } + return nil + }) +} + +func getValue(value initValueType) []byte { + if len(value.Str) != 0 { + return []byte(value.Str) + } else if len(value.Base64) != 0 { + bytes, err := base64.StdEncoding.DecodeString(value.Base64) + if err != nil { + panic(err) + } + return bytes + } + return []byte{} +} diff --git a/examples/init.yaml b/examples/init.yaml new file mode 100644 index 0000000..d7eb25b --- /dev/null +++ b/examples/init.yaml @@ -0,0 +1,298 @@ +kv: + graduated-projects: + containerd: + str: containerd + CoreDNS: + str: CoreDNS + Envoy: + str: Envoy + etcd: + str: etcd + Fluentd: + str: Fluentd + Harbor: + str: Harbor + incubating-projects: + Argo: + str: Argo + Backstage: + str: Backstage + Buildpacks: + str: Buildpacks + Chaos: + str: Chaos + Cilium: + str: Cilium + CloudEvents: + str: CloudEvents + Container: + str: Container + Contour: + str: Contour + Cortex: + str: Cortex + CRI-O: + str: CRI-O + Crossplane: + str: Crossplane + CubeFS: + str: CubeFS + Dapr: + str: Dapr + Dragonfly: + str: Dragonfly + Emissary-Ingress: + str: Emissary-Ingress + Falco: + str: Falco + Flagger": + str: Flagger" + Flux: + str: Flux + gRPC: + str: gRPC + Hubble": + str: Hubble" + in-toto: + str: in-toto + Keda: + str: Keda + Keptn: + str: Keptn + Knative: + str: Knative + KubeEdge: + str: KubeEdge + KubeVirt: + str: KubeVirt + Kyverno: + str: Kyverno + Litmus: + str: Litmus + Longhorn: + str: Longhorn + NATS: + str: NATS + Notary: + str: Notary + OpenMetrics: + str: OpenMetrics + OpenTelemetry: + str: OpenTelemetry + Operator: + str: Operator + SPIFFE: + str: SPIFFE + SPIRE: + str: SPIRE + Tetragon: + str: Tetragon + Thanos: + str: Thanos + Volcano: + str: Volcano + chinese-poetry-authors: + 李璟: + str: 李璟（916－961年8月12日），即南唐元宗，初名景通，曾更名瑶，字伯玉。徐州彭城（今江苏徐州）人，南唐烈祖李昪长子，五代十国时期南唐第二位皇帝，于943年嗣位。后因受到后周威胁，削去帝号，改称国主，史称南唐中主。\n李璟即位后开始大规模对外用兵，消灭楚、闽二国。他在位时，南唐疆土最大。不过李璟奢侈无度，导致政治腐败，国力下降，被后周夺取淮南江北之地，遂从金陵迁都洪州，称南昌府。961年逝世于南昌，时年四十六岁，葬顺陵。死后获宗主国宋朝特许而被追上庙号元宗，谥号明道崇德文宣孝皇帝。其诗词被收录《南唐二主词》中。\n李璟好读书，多才艺。常与宠臣韩熙载、冯延巳等饮宴赋诗。他的词，感情真挚，风格清新，语言不事雕琢，“小楼吹彻玉笙寒”是流芳千古的名句。 + 李煜: + str: 李煜（937年8月15日―978年8月13日），南唐元宗（即南唐中主）李璟第六子，初名从嘉，字重光，号钟隐、莲峰居士，汉族，生于金陵（今江苏南京），祖籍彭城（今江苏徐州铜山区），南唐最后一位国君。\n北宋建隆二年（961年），李煜继位，尊宋为正统，岁贡以保平安。开宝四年（971年）十月，宋太祖灭南汉，李煜去除唐号，改称“江南国主”。次年，贬损仪制，撤去金陵台殿鸱吻以示尊奉宋廷。开宝八年（975年），李煜兵败降宋，被俘至汴京（今河南开封），授右千牛卫上将军，封违命侯。太平兴国三年（978年）七月七日，李煜死于汴京，追赠太师，追封吴王。世称南唐后主、李后主。\n李煜精书法、工绘画、通音律，诗文均有一定造诣，尤以词的成就最高。李煜的词，继承了晚唐以来温庭筠、韦庄等花间派词人的传统，又受李璟、冯延巳等的影响，语言明快、形象生动、用情真挚，风格鲜明，其亡国后词作更是题材广阔，含意深沉，在晚唐五代词中别树一帜，对后世词坛影响深远。 + images: + containerd: + base64: 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 + core-dns: + base64: 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 + envoy: + base64: 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 + etcd: + base64: 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 + fluentd: + base64: qrwGRCNELJfm8mb8n6X535KXqxj0YQMbVSSLiFfmD2t4K2dKlBJTIe6SZMTEKmsNca9YoKo7AChFpIhIUtmjxnw5B9YPMCF2EfBCoiA2hjhMkhsTrdZnZIrDuBDD1YJOF+dzEyE2gHixUB6aoLbZIpsSr/aF1mXKOGy1/ixPNuBX6euBIieJreZ/IxJy1fwYvVCUmAIxBWKrAnFyDMR0iJ3lOQlRapvRhSJOzKCNTBGvjN8K4nihJDxYxY8VZMrC4tX2JXnywXyxLSIxN0aND+SLEiNU9cFO8nkD8cNcsMtCCTtpkEcoHxc9mItAGBKqyh17LpQkJah5eqX5wfGquThFmhuntscthLnhSr0FxO7yggT1XDw5Hy5OFT+eKc2PS1TFiRdm8yLjVPHgK0A04IAQwAIK2DLAFJANxK1d9V3wl2okDPCADGQBIXBSawZnpAyMSOAzARSCPyASAvnQvOCBUSEogPrPQ1rV0wlkDowWDMzIAU8hzgNRIBf+VgzMkgx5SwZPoEb8D+882Pgw3lzYlOP/Xj+o/aphQ020WqMY9MjSGrQkhhJDiBHEMKI9boQH4H54NHwGweaKe+M+g3l8tSc8JbQRHhGuE9oJtyeL58u+i3IMaIf8YepaZHxbC9wGcnrgwbg/ZIfMOBM3Ak64O/TDxgOhZw+o5ajjVlaF9R333zL45t9Q25FdyCh5GDmIbPf9TLoD3WOIRVnrb+ujijVjqN6coZHv/XO+qb4A9lHfW2KLsYPYGew4dg5rwuoBCzuGNWAXsSNKPLS6ngysrkFv8QPx5EAe8T/88dQ+lZWUu9S4dLp8Uo3lC6fnKzceZ4p0hkycJcpnseHXQcjiSvjOI1iuLq6uACi/NarX11vmwDcEYZ7/qltgDoD/jP7+/qavuij4zj14BG7/O191th3wNXEegLPr+ApZgUqHKx8E+JbQgjvNEJgCS2AH83EFnsAPBIFQEAliQSJIBZNglUVwncvANDALzAPFoBSsAGtBBdgMtoFdYC84AOpBEzgOToML4DK4Du7C1dMBXoJu8A70IQhCQmgIAzFEzBBrxBFxRbyRACQUiUbikVQkHclCJIgCmYUsQEqRVUgFshWpRn5GDiPHkXNIG3IbeYh0Im+QjyiGUlE91AS1QUei3igbjUIT0YloFjoVLUQXosvQcrQK3YPWocfRC+h1tB19ifZgANPEmJg55oR5YxwsFkvDMjEZNgcrwcqwKqwWa4T/81WsHevCPuBEnIGzcCe4giPwJJyPT8Xn4EvxCnwXXoefxK/iD/Fu/AuBRjAmOBJ8CVzCOEIWYRqhmFBG2EE4RDgF91IH4R2RSGQSbYlecC+mErOJM4lLiRuJ+4jNxDbiY2IPiUQyJDmS/EmxJB4pn1RMWk/aQzpGukLqIPVqaGqYabhqhGmkaUg05muUaezWOKpxReOZRh9Zm2xN9iXHkgXkGeTl5O3kRvIlcge5j6JDsaX4UxIp2ZR5lHJKLeUU5R7lraampoWmj+ZYTbFmkWa55n7Ns5oPNT9QdakOVA51AlVBXUbdSW2m3qa+pdFoNrQgWhotn7aMVk07QXtA66Uz6M50Ll1An0uvpNfRr9BfaZG1rLXYWpO0CrXKtA5qXdLq0iZr22hztHnac7QrtQ9r39Tu0WHojNKJ1cnTWaqzW+ecznNdkq6NbqiuQHeh7jbdE7qPGRjDksFh8BkLGNsZpxgdekQ9Wz2uXrZeqd5evVa9bn1dfXf9ZP3p+pX6R/TbmRjThsll5jKXMw8wbzA/DjMZxh4mHLZkWO2wK8PeGww3CDIQGpQY7DO4bvDRkGUYaphjuNKw3vC+EW7kYDTWaJrRJqNTRl3D9Yb7DecPLxl+YPgdY9TYwTjeeKbxNuOLxj0mpibhJlKT9SYnTLpMmaZBptmma0yPmnaaMcwCzMRma8yOmb1g6bPYrFxWOeskq9vc2DzCXGG+1bzVvM/C1iLJYr7FPov7lhRLb8tMyzWWLZbdVmZWY6xmWdVY3bEmW3tbi6zXWZ+xfm9ja5Nis8im3ua5rYEt17bQtsb2nh3NLtBuql2V3TV7or23fY79RvvLDqiDh4PIodLhkiPq6Okodtzo2DaCMMJnhGRE1YibTlQntlOBU43TQ2emc7TzfOd651cjrUamjVw58szILy4eLrku213ujtIdFTlq/qjGUW9cHVz5rpWu19xobmFuc90a3F67O7oL3Te53/JgeIzxWOTR4vHZ08tT5lnr2ell5ZXutcHrpreed5z3Uu+zPgSfYJ+5Pk0+H3w9ffN9D/j+6efkl+O32+/5aNvRwtHbRz/2t/Dn+W/1bw9gBaQHbAloDzQP5AVWBT4KsgwSBO0Iesa2Z2ez97BfBbsEy4IPBb/n+HJmc5pDsJDwkJKQ1lDd0KTQitAHYRZhWWE1Yd3hHuEzw5sjCBFRESsjbnJNuHxuNbc70ityduTJKGpUQlRF1KNoh2hZdOMYdEzkmNVj7sVYx0hi6mNBLDd2dez9ONu4qXG/jiWOjRtbOfZp/Kj4WfFnEhgJkxN2J7xLDE5cnng3yS5JkdSSrJU8Ibk6+X1KSMqqlPZxI8fNHnch1ShVnNqQRkpLTtuR1jM+dPza8R0TPCYUT7gx0Xbi9InnJhlNyp10ZLLWZN7kg+mE9JT03emfeLG8Kl5PBjdjQ0Y3n8Nfx38pCBKsEXQK/YWrhM8y/TNXZT7P8s9andUpChSVibrEHHGF+HV2RPbm7Pc5sTk7c/pzU3L35WnkpecdluhKciQnp5hOmT6lTeooLZa2T/WdunZqtyxKtkOOyCfKG/L14KH+osJO8YPiYUFAQWVB77TkaQen60yXTL84w2HGkhnPCsMKf5qJz+TPbJllPmverIez2bO3zkHmZMxpmWs5d+HcjqLwol3zKPNy5v0232X+qvl/LUhZ0LjQZGHRwsc/hP9QU0wvlhXfXOS3aPNifLF4cesStyXrl3wpEZScL3UpLSv9tJS/9PyPo34s/7F/Weay1uWeyzetIK6QrLixMnDlrlU6qwpXPV49ZnXdGtaakjV/rZ289lyZe9nmdZR1inXt5dHlDeut1q9Y/6lCVHG9Mrhy3wbjDUs2vN8o2HhlU9Cm2s0mm0s3f9wi3nJra/jWuiqbqrJtxG0F255uT95+5ifvn6p3GO0o3fF5p2Rn+674XServaqrdxvvXl6D1ihqOvdM2HN5b8jehlqn2q37mPtK94P9iv0vfk7/+caBqAMtB70P1v5i/cuGQ4xDJXVI3Yy67npRfXtDakPb4cjDLY1+jYd+df51Z5N5U+UR/SPLj1KOLjzaf6zwWE+ztLnreNbxxy2TW+6eGHfi2smxJ1tPRZ06ezrs9Ikz7DPHzvqfbTrne+7wee/z9Rc8L9Rd9Lh46DeP3w61erbWXfK61HDZ53Jj2+i2o1cCrxy/GnL19DXutQvXY6633Ui6cevmhJvttwS3nt/Ovf36TsGdvrtF9wj3Su5r3y97YPyg6nf73/e1e7YfeRjy8OKjhEd3H/Mfv3wif/KpY+FT2tOyZ2bPqp+7Pm/qDOu8/GL8i46X0pd9XcV/6Pyx4ZXdq1/+DPrzYve47o7Xstf9b5a+NXy78y/3v1p64noevMt71/e+pNewd9cH7w9nPqZ8fNY37RPpU/ln+8+NX6K+3OvP6++X8mS8gaMABhuamQnAm50A0FIBYMAzBGW86i44IIjq/jqAwH/CqvvigHgCUAs75TGe0wzAfthsiiA37JVH+MQggLq5DTW1yDPdXFVcVHgTIvT29781AYDUCMBnWX9/38b+/s/bYbC3AWieqrqDKoUI7wxb/JXouoGgCHwnqvvpNzl+3wNlBO7g+/5fBRiQsTVNYpAAAABsZVhJZk1NACoAAAAIAAQBGgAFAAAAAQAAAD4BGwAFAAAAAQAAAEYBKAADAAAAAQACAACHaQAEAAAAAQAAAE4AAAAAAAAAkAAAAAEAAACQAAAAAQACoAIABAAAAAEAAAGEoAMABAAAAAEAAAHAAAAAAC1R97MAAAAJcEhZcwAAFiUAABYlAUlSJPAAAEAASURBVHgB7Z0JgBxF3fb/e2dzbEggIYQEwmGAcHyAKEEO8eJ8PbgPEbk+QOUSwU9Ubt73RQE5vFARFeUGEV8BCb4eyJUIGDkCCLnInWyy2fve+f5PVddMz2zP7Ozu9O709FO66enq6n9V/aqpp46u6rLe3t6E0JEACZAACcSeQHnsCRAACZAACZCAIUBB4INAAiRAAiRgCFAQ+CCQAAmQAAkYAhQEPggkQAIkQAKGAAWBDwIJkAAJkIAhQEHgg0ACJEACJGAIUBD4IJAACZAACRgCFAQ+CCRAAiRAAoYABYEPAgmQAAmQgCFAQeCDQAIkQAIkYAhQEPggkAAJkAAJGAIUBD4IJEACJEAChgAFgQ8CCZAACZCAIUBB4INAAiRAAiRgCFAQ+CCQAAmQAAkYAhQEPggkQAIkQAKGAAWBDwIJkAAJkIAhQEHgg0ACJEACJGAIUBD4IJAACZAACRgCFAQ+CCRAAiRAAoYABYEPAgmQAAmQgCFAQeCDQAIkQAIkYAhQEPggkAAJkAAJGAIUBD4IJEACJEAChgAFgQ8CCZAACZCAIUBB4INAAiRAAiRgCFAQ+CCQAAmQAAkYAhQEPggkQAIkQAKGAAWBDwIJkAAJkIAhQEHgg0ACJEACJGAIUBD4IJAACZAACRgCFAQ+CCRAAiRAAoYABYEPAgmQAAmQgCFAQeCDQAIkQAIkYAhQEPggkAAJkAAJGAIUBD4IJEACJEAChgAFgQ8CCZAACZCAIUBB4INAAiRAAiRgCFAQ+CCQAAmQAAkYAhQEPggkQAIkQAKGAAWBDwIJkAAJkIAhQEHgg0ACJEACJGAIUBD4IJAACZAACRgCFAQ+CCRAAiRAAoYABYEPAgmQAAmQgCFAQeCDQAIkQAIkYAhQEPggkAAJkAAJGAIUBD4IJEACJEAChgAFgQ8CCZAACZCAIUBB4INAAiRAAiRgCFAQ+CCQAAmQAAkYAhQEPggkQAIkQAKGAAWBDwIJkAAJkIAhQEHgg0ACJEACJGAIUBD4IJAACZAACRgCFAQ+CCRAAiRAAoYABYEPAgmQAAmQgCFAQeCDQAIkQAIkYAhQEPggkAAJkAAJGAIUBD4IJEACJEAChgAFgQ8CCZAACZCAIUBB4INAAiRAAiRgCFAQ+CCQAAmQAAkYAhQEPggkQAIkQAKGAAWBDwIJkAAJkIAhQEHgg0ACJEACJGAIUBD4IJAACZAACRgCFAQ+CCRAAiRAAoYABYEPAgmQAAmQgCFAQeCDQAIkQAIkYAhQEPggkAAJkAAJGAIUBD4IJEACJEAChgAFgQ8CCZAACZCAIUBB4INAAiRAAiRgCFAQ+CCQAAmQAAkYAhQEPggkQAIkQAKGQCU5kMBABF54Z4O89n6TtPX0SXeiTCrKyqS2qkzqaipkuy3Hyr47TZYJ+puOBEgg2gTKent7E9HOAlMfBoHWjl55eP4KaUhUyJixNYKHJNFnH5W+hB7xfz0afz32tHfJxPI+OWTXLWWXbSeGkSTaJAESCJkABSFkwFE0/+yi9bJwU49Uj6lKFwEpSz/3i4JPLLpa2mSPrcfKp/fbNorZZ5pJILYEKAixLfrgjP/59XXyTptIRWWF9HmVfLIn4Kv0M3sIODc9BzWLngR6Dp3tnTK9pkxOO3QHqSovC46QviRAAkVDgIJQNEUx+glZWd8qv3+vWSqrKlPDQX4RyLOHgJw4UYCY9HT1yMyxKgwHzxKdfqAjARIoUgIUhCItmNFI1s1PvisTp002YoD4h9tDgBjYnoPNTWdbp+y/ba0cvi+HkkajfBknCQxEgIIwEKGYXF+4dJO8vDlhh32yzA3IEHsIacNJKhLdjS1y1qGzZMZW42JCl9kkgWgQ4DqEaJRT6Kn861v1Zty/TCt9uDKM7agwmGPyPGGGfDBDYEMhAEL7/HGOnoHzN1dTdnChsm683P3SWrlr3ru4mY4ESKBICFAQiqQgRjsZPVVVpg6308Go022lbo6aOHuubxkZbz2aBGutb374/HHuiQkqf3Pq7jf32DsrqipkXaJKvv3Qm/Lq4npzhf+QAAmMLgEOGY0u/6KIfUNjuzy+pM3W7VpfOxEo9BwC7EJQnH038axrYaQu0SNfOXK2VFeYrkVRcGEiSCBuBNhDiFuJB+R3xSZ9z1SdGe3x2v62R+CrvE3XwNcTcHeYBr/PH+d59BD89svLy6W5vEpu+P278r9vrDeW+Q8JkMDIE6AgjDzzoouxvbPXzBWYutzIAup0OxwUxhwCAATZr6iulOeWt8iNj78l3VxAX3TPCRNU+gQoCKVfxgPmsEMFAS320eohIIHJ+DUdHRXVcs1v35JF7zcMmHYGIAESKBwBCkLhWEbWUnVNZVH0EOxok51DqKqtkQcXbpS7nnkvslyZcBKIGgEKQtRKLIT0jtOdSpMt9FGYQ0CWkvFjrsJ6qEiJLG9LyLfvf03qdeKbjgRIIFwCFIRw+UbC+jZ11UXXQ4AaQBvK9Vg2tlZuemqJPL9oXSR4MpEkEFUCFISollwB073NluOltaWjaOYQTNYwp6E9BLdhHnZeffLtRvnhE28XMOc0RQIk4CdAQfDTiPHvno4ubxGZHcMPegsITXZU0sNdqQzMQfb9cwj+HoIpFo1Y306Vtd3lcsW9HEKK8aPKrIdIgIIQItwoma7s6ynqHoIZP9IUYhipYuwYuemPS+TZNzmEFKVnjGktfgIUhOIvoxFJ4bTx+jEcjWkk9jJChobSQ0DfxPRQNKGVutXGU29tlh89+c6I8GEkJBAHAhSEOJRyHnncb9akyPQQIApOHFboW0jfvPdf0tDamUcuGYQESCAXAQpCLjoxurbj9Dpp2NgcmR4C+jJw6GkkamrkP3/3b3nlvQ0xKjFmlQQKT4CCUHimkbVY3Y2JZQwc2XUBqHOxPiB17tuzyPiaGWb95fM3404+f3M1ZQctezhjN8O+nibjw2QBegLuLSOcJ+NBQL8dPavUbS8efGW93PtXLmQDHToSGAoBCsJQqJXoPXvMqItkDwHFgZ4CNsl7bX23XHXfQunu6SvRUmK2SCA8AhSE8NhGzvKhu28t7W0dJt1BLXg02dFQx8SzbeejiY/gPn/TkPf5m6u+lr+/ZY9gvh4IGv7uHBENpoeQvE/td1TUyOX3LJQla5qQODoSIIE8CVAQ8gQVh2AV5VolN3tbYaM2RuWPozr7VtDorkNAgkyyPBFKpsulDx4qTghXPW6M3Pb0Ynnk2cXGl/+QAAkMTIAfyBmYUaxCvLF8kzy/odfkGfUuPmIDZ8fytSfgP9dLaJn3D2fvM/7oAej/3VyACQ8vr2fg/wiPPxx6CHC9Xnz2HD0R659pJ90/Fa6rs0vG9XbItV/8sFRVsP1joPIfEshCgP+FZAETV+89tp8sTfVNXo8guj0Er2Mj1TXV0lU7Qc68+c/yzopNcS1W5psE8iJAQcgLU7wC7VCni9TQEseoka9FjvEa661Hg8QOKyFg0h8XzLgOAthwZhDHs2O6C3olyH5aOA0PM65nYSJw8SCgl4K09MHb+Nv0mDMv3q1nTpNv/eplufvJ100o/kMCJNCfAIeM+jOJvU9nd6/c+eJaqamtNixQ6aKezzpchEpX/+8qb/etZFNZG3+L1NhBUK+STgunQdKGjzLjgwnvvj7vBaKkHWdPj/iZ8sdN9tzFveL9tTKppkzuuOBQGVNdYQPwXxIgAUOAPQQ+CP0I1FRVyPhufdtIW+KpylVr2gj3EJBJ9DhmzJwqrYkKOf6GJ+Uf76ztl3d6kECcCbCHEOfSz5H35rZu+fnL62WM9hJM61rDlkIPAVlOJPpk08ZGWbexQQ7cZWu58vP75yDBSyQQHwLsIcSnrAeV0wljq6SqrbXkeggQA7hJkyfK9Klbyd/fWiPHXPeEvLtq86D4MDAJlCIB9hBKsVQLlKf1DW1y3+sNUqMfp9EBo5LqIQAR5htadN3F+6vWSnlFhXxqz+nytRM+WCB6NEMC0SNAQYhemY1oin/yp8XSVzchsusQ0uZAlFyfNyPtzUObHhBWZy9dvkYqqstlfGWl3HTOgbLDNhNHlHOhI3vlteXy9N/elPeWbpBVq+ulo71Derq6AqMpq6qR2tpa2W77qfKpj86Rk4/eJzAcPUufAAWh9Mt4WDls6eiRu+avlWrMJWRblGZe7YnGW0aA4YaNnChAJDo7u2XJ0lVSoRPq6DoctMtU+fZpc4fFbiRvXvr+Brn/8Zfl1deWyZpVw/twUHnNWDnsE3vLlRccNpJZYFxFQICCUASFUOxJuO/ZZdJQU6vJ1Pf7s4mC319Dpr1SqkMzyVdStbI1+uHVxmmvmvrCmUBqZ7grlfPpIYA/0tEFUVgGUSg30Y/RrTyuPPVDst8u0xCk6Nyb762Tex9bIAsWvC3tra0FT1/d5Elyzx1ny5TJ4wtumwaLkwAFoTjLpehSdeNTi2XCJFsxmMpdK+/k20emhvdV+lq56mVz3a5PsNkx4b374JMmGnqeJg7edYRzYuJEYjjrEGAvqIdgxE7zAVFYqqJQ7okC1sBNGz9GvqXC8IGZk3D7qLpV9S3y43ufl1dfeU8a6+tDT0u1DiXd84P/KzO3Gf28h55ZRiAUBD4EeRGY/856WbBJVw97ofuJQgn0EJA1iFZXl4rC0tVGFKwIlUlfb69sM6FWLjp2b9lv15HtMTz/+mp54oUl8saby2XjilUiXe15lVmhAo2rq5N593+1UOZop4gJUBCKuHCKLWm3PvFvqd5yom2xl2gPAcwhCp0d3bL8fRWFSgwfob+D7TDsdhpj9bsLR35oezn303uFUkSd3X3y3Gsr5bd/e08Wr2qUjsZG6d64XoVAFwuOkjtg7u5y85XHjVLsjHakCFAQRop0CcRT39Qh97xarxvGVfUXhRLqIaCoUPnj7aMVK9epKGCLC4gC/CEN3g/9vd2W4+XgvabL6YfNge+QXEdXrzz7r5Xy0qI18saSetncom8DaUSJ3j5pX7taEq2NQ7Kb7abxY2vkO1edIvvuNcsEWb2uQW7/ydPy7EtvZ7tFM10uD//8Il27UZc9DK9EngAFIfJFOLIZeOj55bKuvMbUj6g0UU2aFrT+cGP9aXMDxt+m0YTXcxMe9/nnGvS8GOYQkFKXPqSnpalV1qyvN+sU4I/tLzxtQFDjkA98L6JSL0ydOFamTR6rx1qZtuU4wTcmICI9Pb2Cir+js0ea2jqlvqlT1m5skcbWbunSit+ojIazBkU6N26UHvQKvIV03pWCHL596Wfl6E/unWaruaVDDjvxO2l+mSf77DNbfnD9SZnePC8hApUllBdmZQQInHjg9vJdnWAeM3Gcxqa1I2o7N5yiRyMKqDVNj0ErQ/0f6lAnFq42NZUubjfhYCYjnFf5Br1lBPOu0s48Wvt2eAc43HX8NskKWIeAyryfGHnxj68bK1N6J0v9pgZtJNvKHfkx+db7bPptfD3qvUoX863e3ObFaxKarOxxn8Hl7jdklJ+5AE99q6q7W9pXvB/q8NDsHfvPgUzQifN99txeXn19uU1IwL8L/7VY6htaZCvv5YKAIPSKOAFuXRHxAhyN5H9h7nRd5ITqz6vMUOmj7vOOtrJEymwlbyQDAYyzR/sFNlTSqfO0cKhs1aPc3WeOXjwIaGrR9PtT9m04E8rdryewV6ZDH9bfHEz8Roy8cGnp8eKZuMV42WL8BO9+e5/JsP6ESJh86v0I7qKzdpAOvY549X/+6zag8THXkZ3OzU3SvvQ9KevuNPfh3jD+vBwEHnLFh7ezLr32kcD76FkaBCgIpVGOI5qLbSbVyo61vsoMlZ2r9Fyth6OrBPVXqqVuLthz1JVek9lUyv5w6o+6NNmzMOG8eNTf1qLp98PX+ttw5syzj9+mbvaGYJy3EwN/Otx9CO/sTZ6yhYypwkZ/8FPn/fD3EBDcXbf2kA69QS+4npK7bgOaO8y11uUrpGfdSilLBjCxhPLPv5f03+W1pbVT/vmG9kwGcIsXr5THn3ltgFC8HFUCFISoltwop/tz+8+U9o26IZxXaZrKVqs2U4l6lSCqQVvloTI2ATXV9mjOUVd6/jiirnXnMAQzxdBDMPnQZE/fdopUIJFwLt3D7CH0aU+rZckSkY4WaxN2Q/677afz0iaQ16zfLP/v+gfyjvemHz4hzy54z3LgvyVFgJPKJVWcI5uZ9Y3t8qO/rZAtJutwijcX4Fr0OEfdaVrI+iPpr7U8KnrXIk8bu/eFM4H0/qA5BOQS9/vtOHvW32uZu/h9x6C9jGAvLR2+8Jn2enU9wjLd4qK8wlbcrodgRMPcZ+tVmx4Ng0TqATDMQY/GqX93S5t0rtFeQZ/9hrV3JTKHTxy6t1x36dGRSS8TOjABCsLAjBgiB4HHX1omrzX0yoTxtalKv58YWAO2crWVOXzSREPP+1XKGSLjRCLMlcomXajEg9Jj/Mt0NXOXrFihO6TqGgU45MP0cPQ6Kn3nkF8zd+COrsek5jv0Www99brnkLHp7ojecYJufHjVpZ+WA/edFb3EM8X9CFAQ+iGhx2AJfPPeV2WCfltgTE1lDlGwlWymKKSJgAZxPQlXURZbD8G2/HXbbH0ddX29vnlkFMB2AVwPAH42nPnRr4fQrq+x9jZsGCzmog4/e/YsufM/T+JnSYu6lAZOHAVhYEYMMQABfIP5vLvmy+67zpSKCl3ZW+I9BCcKG9ZulNbOjkH1ENrWbJC+xo0DEI3m5eqaMXLPbWfKdtO3iGYGmGrhpDIfgmETwDeYr/j0HHn1rZVmAZZpNpsOgTdRrDG4SlR/mfjMebIlba/bFra9jh4CWtrpPQY70Wxb5T47/ezbcIgoFa8b27dfTHMjNbjuhnv84a2/8dF/nD0cU/FutfVk3QwMYay/TT/OXbxeeORT/9ey7H1JqBggXCn+das4nvP1X5v8859oEuDCtGiWW9GlepcZW8jxH5wuD7yySreLnq49BftdAVR8qIJTlS58vErYP/autTwq/2Q4PUdPA28ZGVGACpjrmGtA9n12/Pcl/U3wlD3EqnU51iHgfXrPnLmOiWYXr/9oh7NcPLg/lT4Xbsb202T5EuyOWuFdR9pS+UU42G9dvlIXGrRLAhFH3JVXVElNTbVZhZ2ZlTpdyEcXXQIcMopu2RVlyq/+7euyaG2z7L/bdqYvYFrUWhG7lj7OUTG7lnZU5xBc+pGXjg7dhmLNeinXTe9wbsVGf0Cc1ANrDBIdbUVZXjkTVV4hkydNkD13myH77bmdHLjfjrodB7+NkJNZxC9SECJegMWWfFSDp/98gbR39sq+H9hGqrSnoA194zLFIG2uQUOkiYOe4zqcExNT2+LcjvokRSVVOaeLDSpnOBuvvWbP04eN7Kuo6cNBCNcvPcZg/3Dw3rh+k7S0t5v+Ce6FQ7yty1ZGSwxUBGZtv7Ucd+Te8rlP7hHYC7C547+lSICCUIqlOsp5WqfrEy58+HXBoqu9Zk3Tt4+83VE1XZmikFbpasWaWfkX61tGKRGysDFH8L4OHekYV7KH0LoCO5XqgrMIuHETJsiRH99DLjjtIKnWjwPRxZMABSGe5R56rv/6xlr54QJtHasozJpcJ1O2xF5AGS147QGgEe8q1zRxgH+EeggAivUJq1frdtk6dNS2Vl8t3bwJ3kXt6iZOkPNOPVCOOSycbzsUdeaZuH4EKAj9kNCjUAS++7vX5JXGbunrScgErdxn77B1P1FIE4GI9xDAbfPGJlm3eJmuMyhuMajUfZlO+I995cLTDylUcdNOCRCgIJRAIRZzFs648wVpH6PfT1CXaO6QPXfexr6BhPMS6yGgp1O/bqOsf3uxJPSNomJ0qs0yZWKN/PJ7Z8pU7bXRkYCfAAcL/TT4u+AEbvn8vtLX0aM9AzWte+4v1J02Nze22mEi8xIOLthhI/OCpwloPMxYfPqcAiZ07Vs8ekfyPne/8TD+Nly6v3v7J31CGZW4e4XUH976Gx/9x9kLnlC2oRKyub5RmptbZMzWW5nI8LZRsfz1Kq5m7bUc8sHt5clfXUQxQKHR9SPAHkI/JPQoNIHn3l4nd7ywwtaOarxPVzaP01eFZuuEM6r1UphDaGlskQ26JYVZ56C56tA5hL620Z9Q7tFeWPMmXRnd1yM3fOtUfXto30IXL+2VEAEKQgkVZjFn5Y6n35bnVrei9jfJxHBRb3uXbFVbLTO33cqKgl5K7xEU326nTrxSR6w365SVy1cnN7szPR3NZduy5cn8jnTZQAhaVAh6dPVwZWWl/PiWc+Wj+88e6WQwvogRoCBErMCinNyzdb+j5gpdHK+VFZyrVHv0e77bbTVRF0HZRU/OPypvGS1+e5kRA6TbfhnNHvG9iL6mhhErMlDt1t5XW2OD9HbpHkvqUVlVKb+848vy4X12HLF0MKLoEqAgRLfsIpfyTVrxn3vPP6V8TFXyldJkJaq1V0Kv7zB9sozXrbRdT6LY1yEs/bfuT1RmBc4ViOsh4NiyTIfKEmF/76BM2ts7pF3FJ9Gjnzb1EoCewb13Xij77LG9SxqPJJCTAAUhJx5eLDSBP7y8Qu75l34HQJ3rCaDyR2sWEwoJnVuo6OiWnbaboguk7FZbmcNIxbJSeeXS1dLV023y4Sam/T0ErLLo3NQovU36ZbkQnHYGpFMXvnWoECTjVzGwPYMK+fUPL5QP7jUrhJhpslQJUBBKtWSLOF8X//oVWd3p3vbxhlmMIkAQcK6jSvplsgTmGHSztGlbT7K1nHnbx7bGISa4xYmK/5hIBL0NZO8b7hfTXDwb1tRLU7POiZhp8XTYXgPdNdTNXkZl3rec00MO/qw3Ua5zFm3SrsNCCZ0oNtFnRFiBYaLbvyT777vT4CPgHbEmQEGIdfGPTua79B3IL9y1QPr02wnGeZW7q1tR6Zo6ztT4Ij0dXYKVDFP1U52Tthg36nsZNW5qkg0b7DcNUi1zK0KZPQTko0PD9zY32rwO4V9MEHd3dGhvoNlMEkMF0uIBL32/FdwqKivkZ7eeLwd96ANDiIm3xJ0ABSHuT8Ao5f+PC1fLz19eZSoxU7mh8lfnegiuJW6O2uI33QG9DnGo0rCTJtTKFJ2Ids4fPsweAranWL5Ev4OsexYlB+tdIryjETPfVZw3646nOObjQKK3t0+62tqko6VRpyB0bAh8ggwjsM//sq98Ts497dB8omEYEuhHgILQDwk9RorAl+5eIPV9WptpZWf0wGqC/k7vIaSda+1nRUKHlbp1yET/xlZXydQpdVI7ptrYSYmDzQnO7Z87d8NV9jzf3U77tJJe/M5y3cBO62CvRd7viPSlteA1exoN9jbKtnoZuYUA4BXRDp0T6O3EVtm+Wt5YSD8P6iGcffrh8vUvHWEzxX9JYAgEKAhDgMZbCkNgQ1O7nPebhYIx72Ql7s0hJM+hFL4egvNHzY9L9h976NPJaLVkdlcdP65Gtpg4PmXXBFYR8WakvdPk9bQ9lYxZq05WSKwILVEx6NP/ORFIVdrpPNKrbhsKPZuO9etNfD09akUno7s7O6WjWSeEB6j8jQUkOMgwkqn+u+++kzx214XpCeEZCQySAL+YNkhgDF44AlPqamXvqWPl9YZOaxR1XmbLW2s70+LWSg+Vs7uerB2xN4Tx14Z7TSWqa2nT87aWTlmneyf1dXZLmYpApe5AWqHDPJU6xo6/6upK/auQMbrPEkTC2fUfrUjYWvj9xSvTxMAfLpkutdPXranV11ATWumjYZ/o08lxVNraA9i8bp30dncYf1e5w47tANh8JPPlArgjwiGgdzTx6zmOk7eaTDEo3GMZa0vsIcS6+Ec/891aUZ5853wp009Qwg00h5Crh2CqTNS++D9EAvZMbQy7xjw8zA/nj0VyGArCW00Ij+tYVoB6F5/vhBj1tHVKe2ubjuX3WbsmoLUHP71J/7Sdr/4wnzyaIPYawjSuWS1tm9aZStymLzW85GxkPRrDyaiSwaqqx8j/PnKFTJuSmk8x0fIfEhgCAW5uNwRovKVwBKr0TaMDZnq7bprKFJUkKlVb67rhFHtqW8Q2dq9WduFMZewqX3u/s+MqadSizi4qcC8iKdc0VOo8RLkOXZVXVYngr7JKevXrYZ2dPdLSoCuOdcEXWvtlagxrJSAkOMKe/VNzJv2po0mnS5/GN6ZuCxu/Ceflz7uuFzS4S3/AMS1cis/3rj+dYmAfCP5bAAIUhAJApInhEbj4qDk6xKJv0niVuqkaUbuqQwsdF+wpjtbfVp4I4IXTg63s3Xmqh4C6NPB+GxGi8ex6YuSd9+gbRe0bN6ld/c/ExWPSY8OnpdPEb4Ol4jOGYN7kY8y4cVKGrTtMelLptAFwbiwGH12+XTr0eMxnDpLDD5ljbuc/JFAIAhSEQlCkjWERqKosl10n6UoDU6mOfA8BiXdi4qpkDCG11W9M+usPk0fbY7HhTRXu/E0lD/+UKNgbUvchfM14Hdrx8onrNl7zQ/8xFoOPXjwuHTvP3kG+c8XxGpaOBApHgIJQOJa0NAwCFxyxq9aOqExTLXuYG40eAoaGWtZtMHMJtkfi1fLJ9ASk01Ty8E+JgsHhWvSaE0hDZY3u0+TlE9eTPR4TDiGyiIJnBxHUjhsvv7rtLNxORwIFJUBBKChOGhsqgW0mjZVxvT2mxWyqRNfy9oZR7GnGHAAic+GSlSwqVXinehqoSwPvtxElw5vKWOcFWvWrZ2auAJW4uTFpQFPT376NL10MvGS5iM19iK5mvM6XGHMpO14C9GASFHx0BvV463VfkCm6apuOBApNgIJQaKK0N2QCn9ht6qj2ECAcLes36ttE+MIbWvRuzsKojcmX7bGg8rctftfCd6LjP9obUMmjqrfhq/Q11zKdxE7dZ6+rh4aCSGQ5musinzn6APn4R3aBSToSKDgBCkLBkdLgUAmcfujO9u0dNeDG1m2LHC11WMXRtqxt5WkC4oK5bitZe30oPYQ2iEE3di+18ZtK3MRnPGw8ptJ21+0xFb9Lhz3aG7z0QFyQTv1fRXVtMh/J/Lh4jP0AUdDrM2ZOl5u/faIxy39IIAwCFIQwqNLmkAnU6rcDUIUmW9BeNWobyK7FDvOoNHGwR1eJO3/c7+ygrg283wYwZlp0mKhXVw6b+0x43O/iSxrQWF18KfsuGS4edzSGXfr0PhOdHqtqx6Xy5123CbQhIBs2H6ljuS6su/9H5xuT/IcEwiJAQQiLLO0OicDsqVpZ6p2u5TwSPYTW+s3Sq7uJom42PQt3RCWO2h0pMkdU1Tj3wnlHe25Fx4mBFzztPpMv3/3ODo7Wvg2RKQY4v/5bn5ett6ozQfkPCYRFgIIQFlnaHRKBvbefZNvHvpY1qmF76lrsMI3KEwd7dJW588+3h9CmYtDT2qpmUPnDnO9o4vUqaRePF6/fvkuGXwy84Kn06X1WWhJSM26Cicfe58+HJz5eSOQb+Tlg/z3lhKP2RXA6EgiVAAUhVLw0PlgC++ywpalyR6KH0K7fKehuaUnGh0p8RHoIujdGMn+uK2GOnvjYFCm6hIyvq9NXTM8eLEaGJ4EhEaAgDAkbbwqLwMwpukOprlpGCxzOjtkXvofQvrlJOhubbI8A8Wh8I9VDsD0eL3+uK2GO6T2EsvJK+f5/nm448B8SGAkCFISRoMw4BkWgTDeMS7agvWET25BOtaztcIqa9VrYrjJ3/qalby5bMfHf39agYtBgv2DWP5wLr0f9n02H6TqYPBRiDqFqzJhU/rz023yk9xDOOPUTcuB++uYVHQmMEAEKwgiBZjT5E6isQKUcTg+hVT9678QAKfLPBThRSR5VjGw6tOWelp70+6wdq00IZu/38uu7z7b/8ZnLqlT+vOvWfqqHMGPmNnLFV470jPBAAiNDgIIwMpwZyyAIVOrCrTB6CG31DdKlw0R+Nxo9BJWTVP4CeghVNTXymx+c508mf5PAiBCgIIwIZkYyKALayi50D6Fl3SbpatYJZNci9xI0Gj0EDGu5dLijv4dw2w1flOlT+X2DQT0zDFwQAhSEgmCkkUIS6NFKu5A9hOY1G6VbP1gP5+y69I5GD6GjpSmZjmR6TE8BW1ofLJ86aDeXPB5JYEQJUBBGFDcjy4dAT4F6CPiATePKddLT0a7RenMSxdBD0G9Eu56BO6KHsN32M3RL6+PyQcQwJBAKAQpCKFhpdFgEKipSLeghvmWEbxo3rVqn3zju9pKCCdvi6CH0dnWm8ufNIYybMEEevPNLXlp5IIHRIUBBGB3ujDULgX+vbtTKcnhzCD0dXdK0ep35BnIqmuLpIfR0d6X1EMpVAH984xmy5RbjUsnlLxIYBQIUhFGAziizE3jq1VVmcMeNrQ92L6Pu1k5pXrdeK1z97rE3TGRjK54eQnd7a1oP4RsXHyNz990pOxReIYERIkBBGCHQjCY/Aq+jh6BB3dj6YFYqdzQ0S8sG/dKZsYD4rAjYmIujh9CnQtXTYfdOQrqO1UnkM0440CaR/5LAKBOgIIxyATD6dAINnZ4EeGPr+fQQEn0JaVlbLx3NzdryxiNtK//UEXEURw+ho1FXSGvy0APac4+d5cZvHJsOgGckMIoEKkcxbkZNAmkEXlu2UaRKJ5TVt38PAZV86u0cV9n3dHZLq/eVM2vMhrPXjSUvDisSzq7naeIxr556r7rievLci8+Ikvd2kpUrmz4312GPqOTh7zsiEnOfplv/BzvtTSoIGm7rrbeSR3/2FZcMHkmgKAiwh1AUxcBEgMBP/7zEVsb6O585hK7mNmlZt0ESfb24AybU9ReBlH/KrvWz50ZCtDa3lbnviEoctbxt0ptb3HCUEQ31SaZTg6WJQTI59gfu6+np1vUQTTJB3yj6/S+/6pLAIwkUDQH2EIqmKOKdkM06Gbymo0dEvwxmqmDTskZVbFv8tmWf6iG0rm+Q7o42DZtss3sAbXhTiQeIw2j2EFo2rJfa2jHyxL2XyaSJY+Nd4Mx9URKgIBRlscQvUd9/6m39+HyFyXi/YRut9O1wTEJ6u3rMEFFfL3oFcEY+Mo54wwgO4uCcDWda9p7Y4Iq/pd+vh6AepgdgL5guAFr6ZvgHPQqTLmfXXPbSCbtq3HY9zLG3p0cqejvlD/deLtP45TNXKDwWGQEKQpEVSByT09TWJQvX6auYVZU6/IOxdlSutjL39xDaG1qko0m3fTCQXGUfdEzWxrDkIfXseXY9TxOPE4l+R1T+EAXEmJYemz4nUvZoRQDBkueIxNxXJuWdbfLY3RdxjyIHnseiJMA5hKIslngl6ooHFhoxQN3tb7GDAirjPm1dN6+pl84WvEVk5QBXrAs6pouAP1zqfs9X7SG0FYOMo16x4b1aHuG8eE147z5YSoqApx2pZJZJpfr96runyvbTJyMoHQkULQH2EIq2aOKRsGcWrpL1vajUUenqvxk9hM6WNmnXD9rYiWMwyazsg849e6byTr/ueh6ObtrwFMQBPQJ31PuH20Oo0q28H7rxWF2FzDkDx5zH4iXAHkLxlk3Jp2yTTiT/5Pnlmk+v0taDa3mjIsaW1W0Nm/V66gtqRjUMGVT6cEHHdBHwh7Mtfutj7kblDytGBDKOesWGNwkzNw2mh1BbUyX33vBZikEKN38VOQH2EIq8gEo1eZ3dfXLBPa+KVOMR9Fr0ekAPobOpTTrMh2y88XsNYbeiAI3Myj7o3LPn7OI27z4Ijd+l9Qhcz8Adh9FDmKI9gge0Z4AeAh0JRIUABSEqJVVi6Tz/FwukWyeRTfveq6T7unqldUOD9PbpDqWmTkfLXDPuG8ZJioe9oBczK3+cj+5bRrvOmiI//RY/f1lij2wsskNBiEUxF1cmz797gbSU+14x1Uq9dcNms64gmVIjElq5e8eo9BA+89HZctlpc5PZ4A8SiBIBCkKUSiviae3SYaJzVAw6KrVnYOr6hHS3dphJYynT4aFyeEID0DPAb23p6yEKPYSqynK55rxD5JB9tot4KTH5cSZAQYhz6Y9g3tdubpev6uulvdVVJtae9i5p29gofQmsTkbdb8f2k2P8Eeoh7LbDVjpEdNQI0mRUJBAOAQpCOFxp1Ufgz6+vkR+/sFzKaqrNR2uw7YSdJ4AImK6C95ZP6pXPKPQQdJcNuVSHhz5z8Ad8ueVPEoguAQpCdMsuEim//rHX5PXNOklcWaFbTug8QVeHNzRkewR2jsAbJtIcRaWHMHNanfzg64fJpAm1kSgHJpIE8iFAQciHEsMMmsCzi9bKj59dKonaGmmrb5Se7g5jo7wCi730p51ESB7tOoDi7yFU6X5LF53yIfmcTh7TkUCpEaAglFqJjnJ+3lnVKDfPe0cadWKgvaVdunVhWRnGViAA6txcgesZuKPrGbijpxroMuhdEJHMV0m9HkbgugQzE23uUwOIVp09Ju1bT7WbEqFMUcIiNHNdj1hN8PEP7yBX/9+DvTt5IIHSI1DW29vr/ospvdwxRyNGYOHyTXLnX5bI2qZ26WrrkES5q8A1CW7CuM/6mToe/+hf6jdO4Zc64i2joOvJ+0zgVHh3f677ACQpSvo7TTo07vSOS0LK1WPuHtvKleccLBPG2glx2KAjgVIkwB5CKZbqCOVpQ3OH3PfCcvnnis1Sv7lVl4P1aIWq7WrUm32+HoH6JSAG5qi1Lpyp6VNHU5mbU/91tWHCjU4PYd9dp8uVZ39EsOqYjgTiQIA9hDiUcgHzuLGlU37596Xy2pomaWhuNzuRil1jlmx5uxa4EQHEHbEewt6zpxkhmDppXAHJ0RQJFD8B9hCKv4xGPYUvvrte/vftDfLuuhZp0IVkfb3aE6jS1jsG1r0nyIgAOgVa+WtHwIiDGZOHGESghwDI/2f21nLlWR+RaVuOxykdCcSOAHsIsSvygTP82Mvvy8tLN8qKTW3SrPsL9agAiK7ELYMAqHM9gFTL3w7zOP/U0ZtHKOIeQoWK1b67bSPfPvMA2ZKftbQFzH9jS4A9hNgWfXrGr39sofxzbbMk0PJXZ8b00dKv1o5AQh8THcu3E7xeJY8TryfgP0ahh4Ac7rjtJPnsIR+QYz+2i8kv/yEBEtD/pPmWER8DP4EG/UbBX95cK397Z62839iuglBhJ4Q1UKrl7038Jlv+xd9D0K2SZNa0iSoCO8txH9vVn2X+JgES8AhQEPgo5CSwpqFN/vTaSllW36KvlHbIGhWJbmxCh2a2uvxFwnvl1BMRca+gZhGV/sNRvp6JVu7uraRUz8X1YHDRXq/V1dE7z5gkn9xvOznmo+wJ2BLjvySQnQAFITsbXslB4LlFa2TBextk2cYWaWztktbuXuno7pGEVsIpkRiBOQSNokrnNsbXVstWdWNlmy3HymwVgaPm7iCT6ritRI4i5CUS6EeAgtAPCT2GS+CZf66QpeubZUNjm76V1CXdPVpra6sd/+B3S0e3tHX2SGdPr573ms/ZmMsIkexBaItff2OoR3e7kBqd1N5i3BiZNqlWtpsyQXaZOUn23nmqTJnENQLDLS/eTwKOAAXBkeCRBEiABGJOwHuRMOYUmH0SIAESIAGztIgYSIAESIAESICCwGeABEiABEjAEuCQEZ8EEiABEiABQ4CCwAeBBEiABEjAEKAg8EEgARIgARIwBCgIfBBIgARIgAQMAQoCHwQSIAESIAFDgILAB4EESIAESMAQoCDwQSABEiABEjAEKAh8EEiABEiABAwBCgIfBBIgARIgAUOAgsAHgQRIgARIwBCgIPBBIAESIAESMAQoCHwQSIAESIAEDAEKAh8EEiABEiABQ4CCwAeBBEiABEjAEKAg8EEgARIgARIwBCrJIRoEGhsbZd4zf5Kn582TxqamwEQ//MD9gf5+z5mzdvCfmt/777+/PPLgA/386REPAi+8+KKcdMqp/TJ7ycUXy9e+ekk//9H24DMcXglQEMJjWxDLK1askFtvv10efuTRgtijERIgARLIRoCCkI1MEfg/9PAj8rXLLy+ClDAJJEACcSBAQSjSUr7muuvk53f/okhTx2SRAAmUIgFOKhdhqd7187spBkVYLkwSCZQ6AfYQiqyEMcF37fXXD5iqbbfdVmbMmDFgOAYgARIggXwJUBDyJTVC4b52+dezxoS3gc4+60w58vDDs4bhBRIgARIYKgEKwlDJhXAfJpFXrlwZaPm4446V2265JfAaPUmABEigEAQ4h1AIigWy8fQz8wItUQwCsdCTBEigwAQoCAUGOlRzZuHZvGf63T5hwgS59qqr+vnTgwRIgAQKTYCCUGiiQ7T35qJFgXcedtinZOLEiYHX6EkCJEAChSTAOYRC0gzB1swZM0OwOnSTWDn98KO/7Wdg7v4flo8ccEA//8F64C2rl+Yv6HfbCTqHMnNmOCxefOklEx+2BJlYV2d+z9ltt1ETYjBeuWpVWprQU9xj9937cRmsR1D5rVy5ItDMS/Pny/duuz3wGjwLVSb+/LrICpVfZ4/H/AhQEPLjFHqoRYveCoxjzpzdAv1Hy3OFTnrfettt/aLHvjeFEIQXX5ovt+lWHZkOglMoQUAF9LTuC/XwI4/Ioiw9M8SP13oP1x7a8ccdV5DKODNP/vM/6h5V8/QP+c/2YkGdihXSc9hhh8kR+jcUl638gmy9pEKJv2xuOGUymPyCfyGerWz5oH+KAAUhxWLEfx1/0skyX1thudy5552f67KsWLY053VeTBGAEAxmXyhUzFgtjr+5c+fKVy++qOAVE3pEt95+R86K1+WgSXsw2NMKfxCrq678duReQY5bfl3ZReVIQYhKSTGdwyJwl1bq1+p2IEN1aCmfpH+Ha8v8lpu+W5DhpEsvu2zImxZCrNBYgFDd9ZM7C5KeobLJ5z68NIEFl0PdpNHlF/zpwiPASeXw2NJyERBARYSKdzhi4M8Gth8/UbeKRm9jqA5pOvyoo4dcOfrjhVAhPW+8+abfu6h+gxXSOFQx8GcG/OnCI0BBCI8tLRcBgUJVRP6sYN7hiKP/Y0iiADFAmnLNXfjjyuc3bOF7BrBdbA5pOkd7MoXMb7HlsZTSwyGjUipN5iWNAHoGA1VE2BMKE7V1dRMFE/huch8t0bfeCp7oRyQYz0dF99D99w1quAZbkwyUJrxqPGe3OTLT26sKE8GL3lqkk87916m4DCM9EJqB0rP7nDnyoKbZ75DnoP2zsCDyxOOP9wdN+w1bA7l8xGAo+R0oXl4fGgEKwtC4FeSu3X1vEGGMdJX3qqHf+G76+iPeLqEbHAHsGJtriAL7Ql16Sf83o9w+UfhSGIY6btE3qh4NeM0WqUHFjgr+rp/+JK/EIU25hjxQAX/tkkuyvk2F1jbmQn5+993S3NzcL06k53ua3muvvrrfNeeBNS35vrGDV57zDevs+4+33Hpbzsnys848Q8vgkqyCivwiP3f/4pd+s/wdIgEKQohwBzLt/w8X//EEvW55zVVXDus/yoHSUIrXUZHgbaJs7uorr5Rzzj4r2+WkP15zxf5RaCWfc+55gZUwKni8OTNQxZkrTXjn/pabbxrwjSFU5hAq9GhOPPmUwPSg8jznrLOyikoycyH/QH7v/kXw9zyQX4joQMyQX/w3coLyz5bfkLMRO/OcQ4hdkZd+htGKxhBKkLvlppvyEgP/vai4HtLvVaMiC3K5dqh14XOlCbZdz8SFz3XEArVc6UGvZrQdWvZBZQCGSPtAYuBP/0D59Yfl7+ERoCAMjx/vLjICaJkG9bSQTCyeO/GE7GPiubLiKqWgMBjue+rpp4MuJf0eeTT4m9hI01BWIOMe9CqC3DO66G603bwsacAQ0VDzi3vpwiVAQQiXL62PMIGns0y8YvIYwy3DcajIMO4d5HLNDeCVUIhGphtumtCrwFxIpkPLfCCByrynkOe58pvPUF22tOBeMKMLjwAFITy2tDwKBLJtIV6o1iXG54Ncrlb5S7odRZDDXMBwXba3gNzbUsO1P5T7s4lyNnaDiaMQNgYTX9zCUhDiVuIlnt+gyhfj1oWofIEOE814TTLToVWOyeUgh03zglwhVt1my5fbsC8o3rD9mpqC10PMndu/NzPYtGTL72DtMHwwAQpCMBf6RpRA0ETmHH1fvpBbiGONwGAc1hAEuXze4w+6z+9XyHz57Q7n95tZNmocytxBZjoKtcFhpl2eWwJ87ZRPQskQyLadRFlZme4imn3XzsECgL0gh2GaoLdnGhuDewiFqsyxViVzEV3meVB66UcCmQQoCJlEeB5ZAljRG+TMfj8nF04QguKAX7ahoWzhC+UftHAxqKdUqPhop3QJcMiodMuWORthAm6riRGOltGRQMEIUBAKhpKG4kygkBPXcebIvI8uAQrC6PJn7CVC4JqrriroxHWJYGE2IkaAghCxAmNyi4sAegbYDmOoK6CLKzdMTdwJcFI57k9ACeU/aHIV2cNq3gP0y2KFdpgzwHvxhXpbqNDpoz0SGCwBCsJgiTF80RLI9Z77cLetKNpMM2EkUEACHDIqIMw4mMq2mCrb4qtiYBL0nYliSFeppmHixODvd2DjQbriJkBBKO7yKbrUZRseKdTeOfOeCf4qWDYhygSERVqZDhvLFfM3hzPTG/XzbCu5s+1xNJj8Ztu0L4whwcGkq1TCUhBKpSRHMB9hVbpYaRz0eUnscJlNiDKznW2zt7v0K2N0wQSyzb2sWLki+IYBfLOtx3jhpeC9ngYwl3Y5266y2eJMu5knAxKgIAyIiAEyCWTblO3a62/IDDqo82wfdhnMhmbZNlDDZzCzbT43qESWYOBscy/z5y8YUm6zlRfKYDg9NTQYsn3ONFucQ8pAjG+iIMS48Iea9Wz/8WGLiIcefmRIZjEUkO0/9rmDeEMIlVvQNwKQKHzZjOPYwcWTrdc3FBFFby5oR9jhlAHK7Zzzzg9MPOLKtwcZaICeSQIUhCQK/siXQO5K9/JBf5wFrcbLtLIOcqjcB/N5Sdi49JKLg0yZj9SceMqpkm0TvMCbYuJ5QJatqYcqomefeWYgOQwJXnv99YMSZogB7gkaTkQk2eIKTAA9cxKgIOTEw4vZCNya5fONCH+utuS+d1v2j9z7beJbw0ce/R+B399FuGyVu99G5m/sOJqthYpK5QiN7+FHgj9pmWkrLufZPjyDCfmhiCjKIFtPDexhM5/hI4g3wmYrL8QRtMNsXMqt0PmkIBSaaEzsYV/6bJ+TBIJb9SPrBxx0sBGGzP/w8R85hADXr73uuqzEjjvu2CH/x/49XT2c7XOL2An00ssuM/EjHZnpy5qgEr6A8gTvIAcR/cjBhxhmf5w3z2wlju3E8ZdrCA6NBqzkDnKwiYYAygE2/XbwG364hniz9Qxg+5qrrgwyT78hEijr7e1NDPFe3lZAArfcelvgx+EfvP++IVeKQcmbOWuHft5oZT3y4AP9/PPxOPvcc2Velu8Y53N/tjAY05731JPZLuflj4r+xJNPkebm5rzC5xtosLyOP+lkmT+//2c0Vyxbmm+UOcMVyj4qYoj0YHgN9HxiDuIkbeGH4X76kzsHPZwYRjpKySZ7CKVUmqOQF7TEgyYkh5MU2Hv4gfuHY8Lci7mOh9ROtlbqsCMoMQOYmC00LwznYK+nQjvYHOzcUqHTUIr2KAilWKojmCdUImjJZxtuGGxSMPYPMSjUWyMQhaeffKLgojXYfEUlfBgiio3/0JMohDDDBnoG3EwwnCeKghAO19hZve2WW0xLMNu4/UBA8B/61VdeKT//6U8LJgYuToyPQ2QuufjiglRKzm6pHp2IZpsUHkq+0VOAMGeb7M/HJtIDG+wZ5ENraGEoCEPjxrsCCKDVhv9gUfHmKwwIh/AvPvd3OefsswKsFsYLPQ5scId4BpO+wsQePSsQUcwroWU/nErcn3PYhOAP1ibixz1ID2zQhUeAu52Gx3ZQlrH0PqhFlm1bgUEZ9wUOimP3Of33//HdMqifruJF5Yu3ibB/Db417P/IPeKrq5toto5Ga3QknT99mHR+6aX5/dI3UHoGy2uw4QeKP/N6mPbRsscfJpzf1DeDXlRefjeULSP8Nl/QN5WwDxY2R2xsbDKmsTke9kOCbSyCLNTwoT/d/B1MgG8ZBXOhLwmQAAnEjgCHjGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCZAACcSOAAUhdkXODJMACZBAMAEKQjAX+pIACZBA7AhQEGJX5MwwCZAACQQToCAEc6EvCRScwJ///Gc555xz5Nlnny24bRokgUIQKOvt7U0UwhBtxIfAJz7xCXnuuecExyeffDI+GR9GTru7u2XbbbeVjRs3yjbbbCPvv/++lJezPTYMpLw1BAJ8IkOAWuome3p6BH/amCj1rBYsf1VVVUYIYBDCQDEoGFoaKiCBygLaoikSIIEcBP72t7/JvHnz5PDDD88RipdIYPQIUBBGjz1jjhmBLbbYQk488cSY5ZrZjRIBDhlFqbSYVhIgARIIkQB7CCHCpen8CWDS9dFHH5Xf/va3snjxYtmwYYPMmDFDdtllF/niF78ohx56aN7GNm/eLL/5zW/MhPfy5culpaXF2PrIRz4iZ599tuy6667G1o9+9CNZtmyZ7Lfffjlb7kjb448/Lg899JC89957sn79etl6661lzz33lNNPP10+/vGPG3t//OMfBW8STZ48Wb7xjW/0S+/dd98tb7/9tuyxxx7mvswAmdcxTwMe9957r/z73/8WzEMcfPDB8tGPflQ+9alPyaRJkzJNBJ6/8MIL8otf/ELefPNNWblypdTV1cnOO+8sJ510khx77LFSU1Nj7N91113m/iuuuCJv24ER0jO6BPCWEf/IYDDPwEEHHYQ30xKf/OQnC/Ls/OEPf0jomzfGJuwG/X3wgx9MaGU6YHwPPPBAYsKECYE2YLeysjJx3333GTsHHHCACaeVela7//znPxMvwYBkAAAOe0lEQVQf+MAHstqDzQsvvDChlXdCRcCE23777QPtHXHEEeb65z73uQGvt7e3Jz772c9mjXennXZKrFixItCOK0sV1cSRRx6Z1QbSfuCBByY2bdqUeOqpp5LhVJBz2nX2eSy9eoM9BP2vgm70CHznO9+Rb33rW5JIJGTs2LGmN3DIIYfI1KlTzauZaJn//ve/l1deeUU+/OEPm1Y6WsdB7gc/+IFcfPHF5pJW/Cb8xz72MdGK37Ts//rXvwr+TjvtNGltbQ0ykea3YMEC0/rXytn4z5kzR2APvRXc/5e//MX8ff/73ze9kK222irt/qGedHZ2ygknnCAqlKY3gF7B/vvvL01NTfKnP/1JfvnLX5pelAqyiR+9lUyHXtLcuXNNOFzDq65IO3oz6MFgghssnn/+edPb+OpXv5ppgudxJECVLz2VD7tMC9VD0CGYZKsUrWodvglsmeqbOQkd1jBhdWI28e677/YL949//CNRXV1twuCIXkcQhzVr1iR22223RFlZWWLcuHEmfFAPQSvUxA477JBMn4pWoL2urq6EVt4m3Pjx481xuD0ErYdMT0aHtALjfOyxx0z6Ee4LX/hCYJjjjz8+mXb05FTAAsPdfvvtaWmHTfYQ4lsncFI5jq2AIshzfX29WbWLpKCF+/TTT8vMmTMDU4YFcBhHr6ioELR8zzjjjH7h/uu//ku0chb0DO6//37RoZJ+YeCBnsczzzxjxtBz9RLQCl+6dKmx8bWvfU2uu+66QHtIE+YrjjnmGNNLCAw0BM+f/exnct555wXe+ZnPfCbJAAsEM91rr70mjzzyiPFGb0sFRMaMGZMZzJxfcMEFctNNNxU07YER0TMSBCgIkSim0kskJlAxBAKHISEdp8+ZSVS4//3f/23CYJhDewTJ8Fj9i+EVOB2nFx2jT14L+oHhk6uvvjroUtLvV7/6lfk9ceJEufHGG5P+QT8gQnfccUfQpSH5YehMW/g57z355JPNdYjW6tWr08K6tMPz5ptvNkNxaQEyTi699NIB+WfcwtMSJUBBKNGCLfZsuUoL4/F4yycfd+6554oO85ig7n6cvPHGG4I3geB0OMscB/onVzgdapLXX3/dmMCbSfmsKp4+fbrsuOOOA0Wb13XMGUAUcjm8feXcyy+/7H6a48KFC81RJ9dl7733TruW7SQXj2z30L/0CFAQSq9Miz5HeJ1S5wFMOt0rm/kkGhUcJlfh8Pqmc6tWrXI/8xYEDE/pWH/yPv+PtWvXmq054DeYinIwYf3xZf6ura3N9Op3rvMVST8MlfkdXi2Fw2Q6hrTycRAhOhKgIPAZGHECGOJAKxwOaw0G47APEBw2h3MO7+c719bW5n4OeHRvD2UGLLS9TPthn7v0F4JF2Gml/eIiQEEorvKIRWqwhYNzjY2N7mdeRzfv4LfhFxXML+TjsNALC8yC3JQpU8xiLVzL1x7CBk3wwn+knZucxzwLXmHNx/3973/PJxjDlDgBCkKJF3AxZg8rZfEuPBxWzw7GufD6Smjytr322kvcEEq+3xrIFU5fSRXMHcDNnz8/r0oVQ2D6SmsyTaP5w6UdYoD0D+SwBqRYxGygtPJ6uAQoCOHypfUsBNyOn3g9MtvQTeatL774ollgBn93P35jotltGofFYgO98QNRwWK4XO7MM880l5E2bE/hhriC7kGvBWGKxWGrDzcR/qUvfUnWrVuXM2l49dTNO+QMyIslT4CCUPJFXJwZREUFh3UF559/vlmpnCulDQ0NJhzCYLjIvXbp7sE6BF1wZk6x6vbHP/6xu5R2hBhgpXNzc7NsueWWadf8J7CP1cJwEK0zdO2De5PJHw5DXkcffbRgVbOb3/BfH43f2223ndx6660maky+H3bYYYGiAJG75JJL5M477yyatI8GL8aZIkBBSLHgrxEkoHvoJCtcLOzKtXUCJkexGAuvl8Kh8s98LRPj/m7BGcKg1Yv1Bqeccopga4mLLrpIMLSEP4gBtsSYPXs2ggY6t+BM9xMy13X/IyMgRx11lHz3u9816xiw6AuL6rB53A033CC6ajjQ1mh4Iv/YFgQO3DCvgLeOvvnNb8ott9wiyBe22gCbT3/60/LDH/5wNJLJOIuMAPcyKrICiVJyMGb+61//Ou8kT5s2zbTO3Q1YjYtVte+8846pmFBRYyjH/z4/KltUYjjCoYLPtoIXAoC9frBK+a233jKTxtihFH/OYaHZ//zP/wgE6dprr3XegUcsONPN8uTUU081q32xshkrqvHnHIZmdPsHI0ADDUO5e0bqeNlll5nXZ6+55hrTu0EvBn9+h54Q1nRgl1Y6EqAg8BkYMgEMv2AoJV+Hzdj8G9NhXQHebsFmc/iSGLaLQOWEt4bQ8sbW1dgG2zlsIeFWKzu/zCNawlhUht4CVi/j9VRsf43hHIgAKkBMasNBgOAyexvG0/tH90UyQ0awiS0xsDU33k7CFhjobSDtbj1DPvb8tkfiN7bhRhlBuJEHrNlA/nW3VDPvgg0D4Vza8TsXD1ynK10CFITSLdtI5Azj+E888YSpsDB8odtNi27rbP6QAbzxgxY/hpTyXcSGezBujr9sDou53OK2WbNmZQuW9Me3D/CXy7nVzfnYy2Wn0NfQM7v88stzmnVphxhA7OjiSYCCEM9yH1ausXVyIR2GXfBmDP6wNw9a4dj8Dj0FjPOHUUGhB4EV03DYJnq4Dm/yvPrqq8ZMNnsQvlxuoOv+e/FxnFxvPvnDDvS7r6/P9NAQLlvaB7LB66VBgIJQGuVYMrnA+gL/GoPBZAyTp5iAdsMg2e7FkA/2RYLbZ599zFfIgsLCFoad3CutQWHghwoVr51iaApfH3O2s4UfKX/Mf2DyeKCtMDBJ79Yr6Md+Rip5jKcICfAtoyIsFCZpaATwCiUWZeE1Vv/WFs4aWtTYZRWCgf2KMLSDbbWzObyNg0lsbL+ND/Sg4s90mIzFHkaYzEbFi3mGMHo0mfEOdI6Fd5///OfNMBfeqOro6Oh3CxbTYcIck85wmG/A21x08SXAHkJ8y76kco7WPOYjsOoWby/hD8Mq+H4xVkXrx3dkyZIlyclT7AKK1j/eTMrl8B0BfFkMIoIKH2sdICSYnIU9N+mNOH73u9+Zietc9kbqGtZtIG8YgsN3k/EaLb6jjPRj7QfSjsVoEDkM2WEx35e//OWRSh7jKVICZdpqwheT6EigJAhg6AOvqeLtpaAxdqxqPu6448yrou5to1wZR6V51VVXyYMPPhjYykZlik9T4tVTtzAul72RvAaRxAI1pA3fjAhyEEx8/MettwgKQ7/4EKAgxKesY5VT7OODDeywHgGtZLTgMUmNxWTumwqDAYKWNOwsWrTI2MVcAb6BgMVeA/UyBhNPWGGxZgQs8Ac2SDvemtp9993DipJ2I0iAghDBQmOSSYAESCAMApxUDoMqbZIACZBABAlQECJYaEwyCZAACYRBgIIQBlXaJAESIIEIEqAgRLDQmGQSIAESCIMABSEMqrRJAiRAAhEkQEGIYKExySRAAiQQBgEKQhhUaZMESIAEIkiAghDBQmOSSYAESCAMAhSEMKjSJgmQAAlEkAAFIYKFxiSTAAmQQBgEKAhhUKVNEiABEoggAQpCBAuNSSYBEiCBMAhQEMKgSpskQAIkEEECFIQIFhqTTAIkQAJhEKAghEGVNkmABEggggQoCBEsNCaZBEiABMIgQEEIgyptkgAJkEAECVAQIlhoTDIJkAAJhEGAghAGVdokARIggQgSoCBEsNCYZBIgARIIgwAFIQyqtEkCJEACESRAQYhgoTHJJEACJBAGAQpCGFRpkwRIgAQiSICCEMFCY5JJgARIIAwCFIQwqNImCZAACUSQAAUhgoXGJJMACZBAGAQoCGFQpU0SIAESiCABCkIEC41JJgESIIEwCFAQwqBKmyRAAiQQQQIUhAgWGpNMAiRAAmEQoCCEQZU2SYAESCCCBCgIESw0JpkESIAEwiBAQQiDKm2SAAmQQAQJUBAiWGhMMgmQAAmEQYCCEAZV2iQBEiCBCBKgIESw0JhkEiABEgiDAAUhDKq0SQIkQAIRJEBBiGChMckkQAIkEAYBCkIYVGmTBEiABCJIgIIQwUJjkkmABEggDAIUhDCo0iYJkAAJRJAABSGChcYkkwAJkEAYBCgIYVClTRIgARKIIAEKQgQLjUkmARIggTAIUBDCoEqbJEACJBBBAhSECBYak0wCJEACYRCgIIRBlTZJgARIIIIEKAgRLDQmmQRIgATCIEBBCIMqbZIACZBABAlQECJYaEwyCZAACYRBgIIQBlXaJAESIIEIEqAgRLDQmGQSIAESCIMABSEMqrRJAiRAAhEkQEGIYKExySRAAiQQBgEKQhhUaZMESIAEIkiAghDBQmOSSYAESCAMAhSEMKjSJgmQAAlEkAAFIYKFxiSTAAmQQBgEKAhhUKVNEiABEoggAQpCBAuNSSYBEiCBMAhQEMKgSpskQAIkEEECFIQIFhqTTAIkQAJhEKAghEGVNkmABEggggQoCBEsNCaZBEiABMIgQEEIgyptkgAJkEAECVAQIlhoTDIJkAAJhEGAghAGVdokARIggQgSoCBEsNCYZBIgARIIgwAFIQyqtEkCJEACESRAQYhgoTHJJEACJBAGAQpCGFRpkwRIgAQiSICCEMFCY5JJgARIIAwCFIQwqNImCZAACUSQAAUhgoXGJJMACZBAGAQoCGFQpU0SIAESiCABCkIEC41JJgESIIEwCFAQwqBKmyRAAiQQQQIUhAgWGpNMAiRAAmEQoCCEQZU2SYAESCCCBCgIESw0JpkESIAEwiBAQQiDKm2SAAmQQAQJUBAiWGhMMgmQAAmEQYCCEAZV2iQBEiCBCBKgIESw0JhkEiABEgiDAAUhDKq0SQIkQAIRJEBBiGChMckkQAIkEAYBCkIYVGmTBEiABCJI4P8DyYhKElD55FwAAAAASUVORK5CYII= +list: + cncf: + graduated-projects: + - str: containerd + - str: CoreDNS + - str: Envoy + - str: etcd + - str: Fluentd + - str: Harbor + - str: Helm + - str: Jaeger + - str: Kubernetes + - str: Linkerd + - str: Open + - str: Prometheus + - str: Rook + - str: The + - str: TiKV + - str: Vitess + incubating-projects: + - str: Argo + - str: Backstage + - str: Buildpacks + - str: Chaos + - str: Cilium + - str: CloudEvents + - str: Container + - str: Contour + - str: Cortex + - str: CRI-O + - str: Crossplane + - str: CubeFS + - str: Dapr + - str: Dragonfly + - str: Emissary-Ingress + - str: Falco + - str: Flagger" + - str: Flux + - str: gRPC + - str: Hubble" + - str: in-toto + - str: Keda + - str: Keptn + - str: Knative + - str: KubeEdge + - str: KubeVirt + - str: Kyverno + - str: Litmus + - str: Longhorn + - str: NATS + - str: Notary + - str: OpenMetrics + - str: OpenTelemetry + - str: Operator + - str: SPIFFE + - str: SPIRE + - str: Tetragon + - str: Thanos + - str: Volcano + events: + acs.oss: + - str: '{"id":"7adc8c1a-645d-4476-bdef-5d6fb57f****","source":"acs.oss","specversion":"1.0","type":"oss:ObjectCreated:PostObject","datacontenttype":"application/json","dataschema":"http://example.com/test.json","subject":"acs:oss:cn-hangzhou:1234567:xls-papk/game_apk/123.jpg","time":"2020-08-17T16:04:46.149Asia/Shanghai","data":{"name":"test","scope":100}}' + - str: '{"id":"7adc8c1a-645d-4476-bdef-5d6fb57f****","source":"acs.oss","specversion":"1.0","type":"oss:ObjectCreated:PostObject","datacontenttype":"application/json","dataschema":"http://example.com/test.json","subject":["acs:oss:cn-hangzhou:1234567:xls-papk/game_apk/123.jpg","acs:acs.aliyuncvc:cn-hangzhou::215672"],"time":"2020-08-17T16:04:46.149Asia/Shanghai","data":{"name":"test","scope":100}}' +set: + cncf: + graduated-projects: + - str: containerd + - str: CoreDNS + - str: Envoy + - str: etcd + - str: Fluentd + - str: Harbor + - str: Helm + - str: Jaeger + - str: Kubernetes + - str: Linkerd + - str: Open + - str: Prometheus + - str: Rook + - str: The + - str: TiKV + - str: Vitess + incubating-projects: + - str: Argo + - str: Backstage + - str: Buildpacks + - str: Chaos + - str: Cilium + - str: CloudEvents + - str: Container + - str: Contour + - str: Cortex + - str: CRI-O + - str: Crossplane + - str: CubeFS + - str: Dapr + - str: Dragonfly + - str: Emissary-Ingress + - str: Falco + - str: Flagger" + - str: Flux + - str: gRPC + - str: Hubble" + - str: in-toto + - str: Keda + - str: Keptn + - str: Knative + - str: KubeEdge + - str: KubeVirt + - str: Kyverno + - str: Litmus + - str: Longhorn + - str: NATS + - str: Notary + - str: OpenMetrics + - str: OpenTelemetry + - str: Operator + - str: SPIFFE + - str: SPIRE + - str: Tetragon + - str: Thanos + - str: Volcano +zset: + cncf: + graduated-projects: + - score: 11 + str: containerd + - score: 12 + str: CoreDNS + - score: 13 + str: Envoy + - score: 14 + str: etcd + - score: 15 + str: Fluentd + - score: 226 + str: Harbor + - score: 17 + str: Helm + - score: 18 + str: Jaeger + - score: 889 + str: Kubernetes + - score: 111 + str: Linkerd + - score: 112 + str: Open + - score: 113 + str: Prometheus + - score: 114 + str: Rook + - score: 11 + str: The + - score: 116 + str: TiKV + - score: 116 + str: Vitess + music: + ea: + - score: 1 + str: Blinding Lights + - score: 2 + str: Dance Monkey + - score: 3 + str: Don't Start Now + - score: 4 + str: Roses + - score: 5 + str: The Box + - score: 6 + str: Rockstar + - score: 7 + str: Someone You Loved + - score: 8 + str: sour candy + - score: 9 + str: Watermelon Sugar + - score: 10 + str: Cardigan + - score: 11 + str: Circles + - score: 12 + str: Only The Young + - score: 13 + str: Rain on Me + - score: 14 + str: No Time to Die + - score: 15 + str: Before You Go \ No newline at end of file diff --git a/go.mod b/go.mod index 78ad918..ebe2593 100644 --- a/go.mod +++ b/go.mod @@ -3,28 +3,47 @@ module nutshttp go 1.17 require ( - github.com/gin-gonic/gin v1.7.7 - github.com/xujiajun/nutsdb v0.8.0 + github.com/gin-gonic/gin v1.8.1 + github.com/xujiajun/nutsdb v0.10.0 ) require ( github.com/bwmarrin/snowflake v0.3.0 // indirect + github.com/fsnotify/fsnotify v1.5.4 // indirect + github.com/gin-contrib/cors v1.4.0 // indirect github.com/gin-contrib/sse v0.1.0 // indirect github.com/go-playground/locales v0.14.0 // indirect github.com/go-playground/universal-translator v0.18.0 // indirect github.com/go-playground/validator/v10 v10.10.1 // indirect + github.com/goccy/go-json v0.9.7 // indirect + github.com/golang-jwt/jwt v3.2.2+incompatible // indirect github.com/golang/protobuf v1.5.2 // indirect + github.com/hashicorp/hcl v1.0.0 // indirect github.com/json-iterator/go v1.1.12 // indirect github.com/leodido/go-urn v1.2.1 // indirect + github.com/magiconair/properties v1.8.6 // indirect github.com/mattn/go-isatty v0.0.14 // indirect + github.com/mitchellh/mapstructure v1.5.0 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/pelletier/go-toml v1.9.5 // indirect + github.com/pelletier/go-toml/v2 v2.0.1 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/spf13/afero v1.8.2 // indirect + github.com/spf13/cast v1.5.0 // indirect + github.com/spf13/jwalterweatherman v1.1.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + github.com/spf13/viper v1.12.0 // indirect + github.com/subosito/gotenv v1.3.0 // indirect github.com/ugorji/go/codec v1.2.7 // indirect github.com/xujiajun/mmap-go v1.0.1 // indirect github.com/xujiajun/utils v0.0.0-20190123093513-8bf096c4f53b // indirect golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4 // indirect - golang.org/x/sys v0.0.0-20220412211240-33da011f77ad // indirect + golang.org/x/net v0.0.0-20220520000938-2e3eb7b945c2 // indirect + golang.org/x/sys v0.0.0-20220823224334-20c2bfdbfe24 // indirect golang.org/x/text v0.3.7 // indirect google.golang.org/protobuf v1.28.0 // indirect + gopkg.in/ini.v1 v1.66.4 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 45a5a82..4c3a019 100644 --- a/go.sum +++ b/go.sum @@ -1,14 +1,77 @@ +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= +cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= +cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= +cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= +cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= +cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= +cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= +cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= +cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= +cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= +cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= +cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= +cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= +cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= +cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= +cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= +cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= +cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= +cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= +cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= +cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= +cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= +cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= +cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= +cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= +cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= +cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= +cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= github.com/bwmarrin/snowflake v0.3.0 h1:xm67bEhkKh6ij1790JB83OujPR5CzNe8QuQqAgISZN0= github.com/bwmarrin/snowflake v0.3.0/go.mod h1:NdZxfVWX+oR6y2K0o6qAYv6gIOP9rjG0/E9WsDpxqwE= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= +github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= +github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= +github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI= +github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU= +github.com/gin-contrib/cors v1.4.0 h1:oJ6gwtUl3lqV0WEIwM/LxPF1QZ5qe2lGWdY2+bz7y0g= +github.com/gin-contrib/cors v1.4.0/go.mod h1:bs9pNM0x/UsmHPBWT2xZz9ROh8xYjYkiURUfmBoMlcs= github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= github.com/gin-gonic/gin v1.7.7 h1:3DoBmSbJbZAWqXJC3SLjAPfutPJJRN1U5pALB7EeTTs= github.com/gin-gonic/gin v1.7.7/go.mod h1:axIBovoeJpVj8S3BwE0uPMTeReE4+AfFtqpqaZ1qq1U= +github.com/gin-gonic/gin v1.8.1 h1:4+fr/el88TOO3ewCmQr8cx/CtZ/umlIRIs5M4NTNjf8= +github.com/gin-gonic/gin v1.8.1/go.mod h1:ji8BvRH1azfM+SYow9zQ6SZMvR8qOMZHmsCuWR9tTTk= +github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A= github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8= @@ -18,18 +81,86 @@ github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+ github.com/go-playground/universal-translator v0.18.0 h1:82dyy6p4OuJq4/CByFNOn/jYrnRPArHwAcmLoJZxyho= github.com/go-playground/universal-translator v0.18.0/go.mod h1:UvRDBj+xPUEGrFYl+lu/H90nyDXpg0fqeB/AQUGNTVA= github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4= +github.com/go-playground/validator/v10 v10.10.0/go.mod h1:74x4gJWsvQexRdW8Pn3dXSGrTK4nAUsbPlLADvpJkos= github.com/go-playground/validator/v10 v10.10.1 h1:uA0+amWMiglNZKZ9FJRKUAe9U3RX91eVn1JYXMWt7ig= github.com/go-playground/validator/v10 v10.10.1/go.mod h1:i+3WkQ1FvaUjjxh1kSvIA4dMGDBiPU55YFDl0WbKdWU= +github.com/goccy/go-json v0.9.7 h1:IcB+Aqpx/iMHu5Yooh7jEzJk1JZ7Pjtmys2ukPr7EeM= +github.com/goccy/go-json v0.9.7/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= +github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= +github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw= github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= +github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= +github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= +github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= +github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0= @@ -41,27 +172,57 @@ github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w= github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY= +github.com/magiconair/properties v1.8.6 h1:5ibWZ6iY0NctNGWo87LalDlEZ6R41TqbbDamhfG/Qzo= +github.com/magiconair/properties v1.8.6/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8= +github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pelletier/go-toml/v2 v2.0.1 h1:8e3L2cCQzLFi2CR4g7vGFuFxX7Jl1kKX8gW+iV0GUKU= +github.com/pelletier/go-toml/v2 v2.0.1/go.mod h1:r9LEWfGN8R5k0VXJ+0BkIe7MYkRdwZOjgMj2KwnJFUo= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8= github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE= +github.com/spf13/afero v1.8.2 h1:xehSyVa0YnHWsJ49JFljMpg1HX19V6NDZ1fkm1Xznbo= +github.com/spf13/afero v1.8.2/go.mod h1:CtAatgMJh6bJEIs48Ay/FOnkljP3WeGUG0MC1RfAqwo= +github.com/spf13/cast v1.5.0 h1:rj3WzYc11XZaIZMPKmwP96zkFEnnAmV8s6XbB2aY32w= +github.com/spf13/cast v1.5.0/go.mod h1:SpXXQ5YoyJw6s3/6cMTQuxvgRl3PCJiyaX9p6b155UU= +github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk= +github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.12.0 h1:CZ7eSOd3kZoaYDLbXnmzgQI5RlciuXBMA+18HwHRfZQ= +github.com/spf13/viper v1.12.0/go.mod h1:b6COn30jlNxbm/V2IqWiNWkJ+vZNiMNksliPCiuKtSI= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/subosito/gotenv v1.3.0 h1:mjC+YW8QpAdXibNi+vNWgzmgBH4+5l5dCXv8cNysBLI= +github.com/subosito/gotenv v1.3.0/go.mod h1:YzJjq/33h7nrwdY+iHMhEOEEbW0ovIz0tB6t6PwAXzs= github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw= github.com/ugorji/go v1.2.7 h1:qYhyWUUd6WbiM+C6JZAUkIJt/1WrjzNHY9+KCIjVqTo= github.com/ugorji/go v1.2.7/go.mod h1:nF9osbDWLy6bDVv/Rtoh6QgnvNDpmCalQV5urGCCS6M= @@ -73,35 +234,315 @@ github.com/xujiajun/mmap-go v1.0.1 h1:7Se7ss1fLPPRW+ePgqGpCkfGIZzJV6JPq9Wq9iv/WH github.com/xujiajun/mmap-go v1.0.1/go.mod h1:CNN6Sw4SL69Sui00p0zEzcZKbt+5HtEnYUsc6BKKRMg= github.com/xujiajun/nutsdb v0.8.0 h1:BkXjifwlF3akHVoTQ8B3gdF183oq4QI0JQywazEZXkM= github.com/xujiajun/nutsdb v0.8.0/go.mod h1:KOdR/RLPELQ6611VTMsSOUBSO2s7kXPINOiA/+1dlgc= +github.com/xujiajun/nutsdb v0.10.0 h1:kSxd7MyZiAVQM2I79FK74WneGI+uaHsUdak8dbjzKJc= +github.com/xujiajun/nutsdb v0.10.0/go.mod h1:8ZdTTF0cEQO+wN940htfHYKswFql2iB6Osckx+GmOoU= github.com/xujiajun/utils v0.0.0-20190123093513-8bf096c4f53b h1:jKG9OiL4T4xQN3IUrhUpc1tG+HfDXppkgVcrAiiaI/0= github.com/xujiajun/utils v0.0.0-20190123093513-8bf096c4f53b/go.mod h1:AZd87GYJlUzl82Yab2kTjx1EyXSQCAfZDhpTo1SQC4k= +github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= +go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= +go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4 h1:kUhD7nTDoI3fVd9G4ORWrbV5NY0liEs/Jg2pv5f+bBA= golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= +golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= +golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= +golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= +golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= +golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= +golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= +golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220520000938-2e3eb7b945c2 h1:NWy5+hlRbC7HK+PmcXVUmW1IMyFce7to56IUvhUFm7Y= +golang.org/x/net v0.0.0-20220520000938-2e3eb7b945c2/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181221143128-b4a75ba826a6/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220405210540-1e041c57c461/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220412211240-33da011f77ad h1:ntjMns5wyP/fN65tdBD4g8J5w8n015+iIIs9rtjXkY0= golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220823224334-20c2bfdbfe24 h1:TyKJRhyo17yWxOMCTHKWrc5rddHORMlnZ/j57umaUd8= +golang.org/x/sys v0.0.0-20220823224334-20c2bfdbfe24/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= +golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= +golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df h1:5Pf6pFKu98ODmgnpvkJ3kFUOQGGLIzLIkbzUHp47618= +google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= +google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= +google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= +google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= +google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= +google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE= +google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= +google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= +google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= +google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= +google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= +google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= +google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= +google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= +google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= +google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= +google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= +google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw= @@ -111,6 +552,8 @@ gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/ini.v1 v1.66.4 h1:SsAcf+mM7mRZo2nJNGt8mZCjG8ZRaNGMURJw7BsIST4= +gopkg.in/ini.v1 v1.66.4/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= @@ -118,3 +561,17 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0 h1:hjy8E9ON/egN1tAYqKb61G10WtihqetD4sz2H+8nIeA= +gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= +rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= +rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= diff --git a/http.go b/http.go index 0bfad07..f87e465 100644 --- a/http.go +++ b/http.go @@ -1,11 +1,17 @@ package nutshttp import ( + "github.com/spf13/viper" "github.com/xujiajun/nutsdb" + "log" ) func Enable(db *nutsdb.DB) error { - s := NewNutsHTTPServer(db) + server, err := NewNutsHTTPServer(db) + if err != nil { + log.Fatalln(err) + } - return s.Run(":8080") + port := viper.GetString("port") + return server.Run(":" + port) } diff --git a/middleware_auth.go b/middleware_auth.go new file mode 100644 index 0000000..8d1c8f3 --- /dev/null +++ b/middleware_auth.go @@ -0,0 +1,75 @@ +package nutshttp + +import ( + "errors" + "github.com/gin-gonic/gin" + "github.com/golang-jwt/jwt" +) + +var Secret = []byte("nutshttp-secret") + +type Claims struct { + Username string `json:"username"` + jwt.StandardClaims +} + +// GenerateToken generate a jwt based on claims +func GenerateToken(claims Claims) (string, error) { + originalToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) + tokenString, err := originalToken.SignedString(Secret) + if err != nil { + return "", err + } + return tokenString, nil +} + +func parseToken(tokenString string) (*Claims, error) { + var claims Claims + token, err := jwt.ParseWithClaims(tokenString, &claims, func(token *jwt.Token) (interface{}, error) { + return Secret, nil + }) + if err != nil || !token.Valid { + jwtError := handleJWTError(err) + return nil, jwtError + } else { + return &claims, nil + } +} + +func handleJWTError(err error) error { + if validationError, ok := err.(*jwt.ValidationError); ok { + return errors.New("Invalid Token") + } else if validationError.Errors & (jwt.ValidationErrorExpired | jwt.ValidationErrorNotValidYet) != 0 { + return errors.New("Token Expired") + } else { + return errors.New("Invalid Token") + } +} + +func (s *NutsHTTPServer) initAuthMiddleware() { + s.r.Use(func(c *gin.Context) { + // skip login api + if c.Request.RequestURI == "/login" { + c.Next() + return + } + + tokenString := c.GetHeader("Authorization") + if tokenString == "" { + WriteError(c, AuthFail) + c.Abort() + return + } + + _, err := parseToken(tokenString) + if err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + c.Abort() + return + } + + c.Next() + }) +} diff --git a/middleware_cors.go b/middleware_cors.go new file mode 100644 index 0000000..bb23c6d --- /dev/null +++ b/middleware_cors.go @@ -0,0 +1,10 @@ +package nutshttp + +import "github.com/gin-contrib/cors" + +func (s *NutsHTTPServer) initCorsMiddleware() { + config := cors.DefaultConfig() + config.AllowHeaders = append(config.AllowHeaders, "Authorization") + config.AllowAllOrigins = true + s.r.Use(cors.New(config)) +} diff --git a/response.go b/response.go index 5f5c3fe..af03f33 100644 --- a/response.go +++ b/response.go @@ -15,8 +15,15 @@ var ( APIOK = APIMessage{Code: 200, Message: "OK"} ErrBadRequest = APIMessage{Code: 400, Message: "Bad Request"} + AuthFail = APIMessage{401, "Auth Fail"} ErrNotFound = APIMessage{404, "Not Found"} ErrInternalServerError = APIMessage{500, "Internal Server Error"} + ErrKeyNotFoundInBucket = APIMessage{40001, "Key Not Found In Bucket"} + ErrPrefixScan = APIMessage{40002, "Prefix Scans Not Found"} + ErrPrefixSearchScan = APIMessage{40003, "Prefix Search Scans Not Found"} + ErrRangeScan = APIMessage{40004, "Range Scans Not Found"} + ErrBucketEmpty = APIMessage{40005, "Bucket Empty"} + ErrUnknown = APIMessage{40404, "UnKnown Err"} ) type Response struct { @@ -35,7 +42,7 @@ func WriteSucc(c *gin.Context, data interface{}) { } func WriteError(c *gin.Context, msg APIMessage) { - c.JSON(msg.Code, Response{ + c.JSON(http.StatusOK, Response{ Code: msg.Code, Error: msg.Message, }) diff --git a/router_list.go b/router_list.go new file mode 100644 index 0000000..f3a498c --- /dev/null +++ b/router_list.go @@ -0,0 +1,28 @@ +package nutshttp + +func (s *NutsHTTPServer) initListRouter() { + sr := s.r.Group("/list") + + sr.GET("/lrange/:bucket/:key", s.LRange) + + sr.POST("/rpush/:bucket/:key", s.RPush) + + sr.POST("/lpush/:bucket/:key", s.LPush) + + sr.GET("/rpop/:bucket/:key", s.RPop) + + sr.GET("/lpop/:bucket/:key", s.LPop) + + sr.GET("/rpeek/:bucket/:key", s.RPeek) + + sr.GET("/lpeek/:bucket/:key", s.LPeek) + + sr.POST("/lrem/:bucket/:key", s.LRem) + + sr.POST("/lset/:bucket/:key", s.LSet) + + sr.POST("/ltrim/:bucket/:key", s.LTrim) + + sr.GET("/lsize/:bucket/:key", s.LSize) + +} diff --git a/router_login.go b/router_login.go new file mode 100644 index 0000000..1e2d87e --- /dev/null +++ b/router_login.go @@ -0,0 +1,42 @@ +package nutshttp + +import ( + "github.com/gin-gonic/gin" + "github.com/spf13/viper" +) + +type user struct { + UserName string `json:"userName"` + Password string `json:"password"` +} + +func (s *NutsHTTPServer) initLoginRouter() { + + s.r.POST("/login", func(c *gin.Context) { + u := &user{} + err := c.ShouldBindJSON(u) + if err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + //Checking User Status + users := viper.GetStringMapString("users") + + if password, ok := users[u.UserName]; !ok || password != u.Password { + WriteError(c, AuthFail) + } else { + token, err := GenerateToken(Claims{Username: u.UserName}) + if err != nil { + WriteError(c, ErrInternalServerError) + return + } + WriteSucc(c, map[string]interface{}{ + token: token, + }) + } + + }) + +} diff --git a/router_string.go b/router_string.go new file mode 100644 index 0000000..cb1781f --- /dev/null +++ b/router_string.go @@ -0,0 +1,13 @@ +package nutshttp + +func (s *NutsHTTPServer) initStringRouter() { + sr := s.r.Group("/string") + + sr.GET("get/:bucket/:key", s.Get) + + sr.POST("update/:bucket/:key", s.Update) + + sr.POST("delete/:bucket/:key", s.Delete) + + sr.GET("scan/:bucket/:scanType", s.Scan) +} diff --git a/router_zset.go b/router_zset.go new file mode 100644 index 0000000..c3063a3 --- /dev/null +++ b/router_zset.go @@ -0,0 +1,38 @@ +package nutshttp + +func (s *NutsHTTPServer) initZSetRouter() { + sr := s.r.Group("/zset") + + sr.POST("/zadd/:bucket/:key", s.ZAdd) + + sr.GET("/zcard/:bucket/:key", s.ZCard) + + sr.GET("/zcount/:bucket/:key", s.ZCount) + + sr.GET("/zgetbykey/:bucket/:key", s.ZGetByKey) + + sr.GET("/zmembers/:bucket/:key", s.ZMembers) + + sr.GET("/zpeekmax/:bucket/:key", s.ZPeekMax) + + sr.GET("/zpeekmin/:bucket/:key", s.ZPeekMin) + + sr.DELETE("/zpopmax/:bucket/:key", s.ZPopMax) + + sr.DELETE("/zpopmin/:bucket/:key", s.ZPopMin) + + sr.GET("/zrangebyrank/:bucket/:key", s.ZRangeByRank) + + sr.GET("/zrangebyscore/:bucket/:key", s.ZRangeByScore) + + sr.GET("/zrank/:bucket/:key", s.ZRank) + + sr.GET("/zrevrank/:bucket/:key", s.ZRevRank) + + sr.DELETE("/zrem/:bucket/:key", s.ZRem) + + sr.DELETE("/zremrangebyrank/:bucket/:key", s.ZRemRangeByRank) + + sr.GET("/zscore/:bucket/:key", s.ZScore) + +} diff --git a/server.go b/server.go index 11f61b9..aa3bd25 100644 --- a/server.go +++ b/server.go @@ -1,6 +1,7 @@ package nutshttp import ( + "github.com/spf13/viper" "net/http" "github.com/gin-gonic/gin" @@ -12,7 +13,7 @@ type NutsHTTPServer struct { r *gin.Engine } -func NewNutsHTTPServer(db *nutsdb.DB) *NutsHTTPServer { +func NewNutsHTTPServer(db *nutsdb.DB) (*NutsHTTPServer, error) { c := &core{db} r := gin.Default() @@ -22,23 +23,47 @@ func NewNutsHTTPServer(db *nutsdb.DB) *NutsHTTPServer { r: r, } + err := s.InitConfig() + if err != nil { + return nil, err + } + + s.initMiddleware() + s.initRouter() - return s + return s, nil +} + +func (s *NutsHTTPServer) InitConfig() error { + viper.SetConfigType("yaml") + viper.SetConfigName("config") + viper.AddConfigPath(".") + viper.SetDefault("port", "8080") + err := viper.ReadInConfig() + if err != nil { + return err + } + return nil } func (s *NutsHTTPServer) Run(addr string) error { return http.ListenAndServe(addr, s.r) } +func (s *NutsHTTPServer) initMiddleware() { + s.initCorsMiddleware() + s.initAuthMiddleware() +} + func (s *NutsHTTPServer) initRouter() { s.initSetRouter() s.initListRouter() -} -func (s *NutsHTTPServer) initListRouter() { - sr := s.r.Group("/list") + s.initStringRouter() + + s.initZSetRouter() - sr.GET("/:bucket/:key", s.LRange) + s.initLoginRouter() } diff --git a/server_list.go b/server_list.go index 3792f93..bb63839 100644 --- a/server_list.go +++ b/server_list.go @@ -1,30 +1,347 @@ package nutshttp import ( + "fmt" "github.com/gin-gonic/gin" ) -type ReqLRange struct { - Start int `form:"start"` - End int `form:"end"` +type PushRequest struct { + Value string `json:"value" binding:"required"` } func (s *NutsHTTPServer) LRange(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) - bucket := c.Param("bucket") - key := c.Param("key") + type RangeReq struct { + Start *int `form:"start" binding:"required"` + End *int `form:"end" binding:"required"` + } + + var rangeReq RangeReq + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } - var req ReqLRange - if err := c.ShouldBindQuery(&req); err != nil { - WriteError(c, ErrBadRequest) + if err = c.ShouldBindQuery(&rangeReq); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) return } - items, err := s.core.LRange(bucket, []byte(key), req.Start, req.End) + fmt.Println(*rangeReq.Start, " ", *rangeReq.End) + + items, err := s.core.LRange(baseUri.Bucket, baseUri.Key, *rangeReq.Start, *rangeReq.End) if err != nil { - WriteError(c, ErrInternalServerError) + switch err { + default: + WriteError(c, ErrUnknown) + } return } WriteSucc(c, items) } + +func (s *NutsHTTPServer) RPush(c *gin.Context) { + var ( + err error + baseUri BaseUri + rPushReq PushRequest + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + if err = c.ShouldBindJSON(&rPushReq); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + err = s.core.RPush(baseUri.Bucket, baseUri.Key, rPushReq.Value) + if err != nil { + switch err { + default: + WriteError(c, ErrUnknown) + } + } + + WriteSucc(c, struct{}{}) + +} + +func (s *NutsHTTPServer) LPush(c *gin.Context) { + var ( + err error + baseUri BaseUri + rPushReq PushRequest + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + if err = c.ShouldBindJSON(&rPushReq); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + err = s.core.LPush(baseUri.Bucket, baseUri.Key, rPushReq.Value) + if err != nil { + switch err { + default: + WriteError(c, ErrUnknown) + } + } + + WriteSucc(c, struct{}{}) +} + +func (s *NutsHTTPServer) RPop(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + pop, err := s.core.RPop(baseUri.Bucket, baseUri.Key) + if err != nil { + switch err { + default: + WriteError(c, ErrUnknown) + } + } + WriteSucc(c, pop) +} + +func (s *NutsHTTPServer) LPop(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + pop, err := s.core.LPop(baseUri.Bucket, baseUri.Key) + if err != nil { + switch err { + default: + WriteError(c, ErrUnknown) + } + } + WriteSucc(c, pop) +} + +func (s *NutsHTTPServer) RPeek(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + peek, err := s.core.RPeek(baseUri.Bucket, baseUri.Key) + if err != nil { + switch err { + default: + WriteError(c, ErrUnknown) + } + } + WriteSucc(c, peek) +} + +func (s *NutsHTTPServer) LPeek(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + peek, err := s.core.RPeek(baseUri.Bucket, baseUri.Key) + if err != nil { + switch err { + default: + WriteError(c, ErrUnknown) + } + } + WriteSucc(c, peek) +} + +func (s *NutsHTTPServer) LRem(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) + + type LRemReq struct { + Value *string `json:"value" binding:"required"` + Count *int `json:"count" binding:"required"` + } + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + var lremReq LRemReq + if err = c.ShouldBindJSON(&lremReq); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + num, err := s.core.LRem(baseUri.Bucket, baseUri.Key, *lremReq.Value, *lremReq.Count) + if err != nil { + switch err { + default: + WriteError(c, ErrUnknown) + } + return + } + WriteSucc(c, num) +} + +func (s *NutsHTTPServer) LSet(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) + + type SetReq struct { + Value *string `json:"value" binding:"required"` + Index *int `json:"index" binding:"required"` + } + + var setReq SetReq + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + if err = c.ShouldBindJSON(&setReq); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + err = s.core.LSet(baseUri.Bucket, baseUri.Key, *setReq.Value, *setReq.Index) + if err != nil { + switch err { + default: + WriteError(c, ErrUnknown) + } + return + } + WriteSucc(c, struct{}{}) + +} + +func (s *NutsHTTPServer) LTrim(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) + + type TrimReq struct { + Start *int `json:"start" binding:"required"` + End *int `json:"end" binding:"required"` + } + + var trimReq TrimReq + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + if err = c.ShouldBindJSON(&trimReq); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + err = s.core.LTrim(baseUri.Bucket, baseUri.Key, *trimReq.Start, *trimReq.End) + if err != nil { + switch err { + default: + WriteError(c, ErrUnknown) + } + return + } + WriteSucc(c, struct{}{}) +} + +func (s *NutsHTTPServer) LSize(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + size, err := s.core.LSize(baseUri.Bucket, baseUri.Key) + if err != nil { + switch err { + default: + WriteError(c, ErrUnknown) + } + return + } + + WriteSucc(c, size) + +} diff --git a/server_set.go b/server_set.go index 63384d4..975ec8c 100644 --- a/server_set.go +++ b/server_set.go @@ -132,10 +132,10 @@ func (s *NutsHTTPServer) SIsMember(c *gin.Context) { ) var ( - ok bool - err error - baseUri BaseUri - sIsMembersquest SIsMemberRequest + ok bool + err error + baseUri BaseUri + sIsMembersRequest SIsMemberRequest ) if err = c.ShouldBindUri(&baseUri); err != nil { @@ -146,7 +146,7 @@ func (s *NutsHTTPServer) SIsMember(c *gin.Context) { return } - if err = c.ShouldBindJSON(&sIsMembersquest); err != nil { + if err = c.ShouldBindJSON(&sIsMembersRequest); err != nil { WriteError(c, APIMessage{ Message: err.Error(), }) @@ -154,7 +154,7 @@ func (s *NutsHTTPServer) SIsMember(c *gin.Context) { return } - if ok, err = s.core.sIsMember(baseUri.Bucket, baseUri.Key, sIsMembersquest.Value); err != nil { + if ok, err = s.core.sIsMember(baseUri.Bucket, baseUri.Key, sIsMembersRequest.Value); err != nil { WriteError(c, APIMessage{ Message: err.Error(), }) diff --git a/server_string.go b/server_string.go new file mode 100644 index 0000000..76352ac --- /dev/null +++ b/server_string.go @@ -0,0 +1,243 @@ +package nutshttp + +import ( + "github.com/gin-gonic/gin" + "github.com/xujiajun/nutsdb" +) + +func (s *NutsHTTPServer) Get(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + value, err := s.core.Get(baseUri.Bucket, baseUri.Key) + if err != nil { + switch err { + case nutsdb.ErrNotFoundKey: + WriteError(c, ErrKeyNotFoundInBucket) + default: + WriteError(c, ErrUnknown) + } + return + } + + WriteSucc(c, value) + +} + +func (s *NutsHTTPServer) Update(c *gin.Context) { + type UpdateStringRequest struct { + Value string `json:"value" binding:"required"` + Ttl uint32 `json:"ttl"` + } + var ( + err error + baseUri BaseUri + updateStringRequest UpdateStringRequest + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + if err = c.ShouldBindJSON(&updateStringRequest); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + err = s.core.Update(baseUri.Bucket, baseUri.Key, updateStringRequest.Value, updateStringRequest.Ttl) + if err != nil { + switch err { + case nutsdb.ErrNotFoundKey: + WriteError(c, ErrKeyNotFoundInBucket) + default: + WriteError(c, ErrUnknown) + } + return + } + WriteSucc(c, struct{}{}) +} + +func (s *NutsHTTPServer) Delete(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + _, err = s.core.Get(baseUri.Bucket, baseUri.Key) + if err != nil { + switch err { + case nutsdb.ErrNotFoundKey: + WriteError(c, ErrKeyNotFoundInBucket) + default: + WriteError(c, ErrUnknown) + } + return + } + + err = s.core.Delete(baseUri.Bucket, baseUri.Key) + + if err != nil { + switch err { + case nutsdb.ErrKeyEmpty: + WriteError(c, ErrKeyNotFoundInBucket) + default: + WriteError(c, ErrUnknown) + } + return + } + WriteSucc(c, struct{}{}) +} + +func (s *NutsHTTPServer) Scan(c *gin.Context) { + const ( + PrefixScan = "prefixScan" + PrefixSearchScan = "prefixSearchScan" + RangeScan = "rangeScan" + GetAll = "getAll" + ) + + type ScanParam struct { + Bucket string `uri:"bucket" binding:"required"` + ScanType string `uri:"scanType" binding:"required"` + } + + var ( + err error + entries nutsdb.Entries + scanParam ScanParam + ) + + if err = c.ShouldBindUri(&scanParam); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + + switch scanParam.ScanType { + case PrefixScan: + type ScanRequest struct { + OffSet *int `form:"offSet" binding:"required"` + LimitNum *int `form:"limitNum" binding:"required"` + Prefix *string `form:"prefix" binding:"required"` + } + + var scanReq ScanRequest + if err = c.ShouldBindQuery(&scanReq); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + entries, err = s.core.PrefixScan(scanParam.Bucket, *scanReq.Prefix, *scanReq.OffSet, *scanReq.LimitNum) + if err != nil { + switch err { + case nutsdb.ErrPrefixScan: + WriteError(c, ErrPrefixScan) + default: + WriteError(c, ErrUnknown) + } + return + } + var res = map[string]string{} + for _, e := range entries { + res[string(e.Key)] = string(e.Value) + } + WriteSucc(c, res) + case PrefixSearchScan: + type ScanSearchReq struct { + OffSet *int `form:"offSet" binding:"required"` + LimitNum *int `form:"limitNum" binding:"required"` + Prefix *string `form:"prefix" binding:"required"` + Reg *string `form:"reg" binding:"required"` + } + var scanSearchReq ScanSearchReq + if err = c.ShouldBindQuery(&scanSearchReq); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + entries, err = s.core.PrefixSearchScan(scanParam.Bucket, *scanSearchReq.Prefix, *scanSearchReq.Reg, *scanSearchReq.OffSet, *scanSearchReq.LimitNum) + if err != nil { + switch err { + case nutsdb.ErrPrefixSearchScan: + WriteError(c, ErrPrefixSearchScan) + default: + WriteError(c, ErrUnknown) + } + return + } + var res = map[string]string{} + for _, e := range entries { + res[string(e.Key)] = string(e.Value) + } + WriteSucc(c, res) + case RangeScan: + type RangeScanReq struct { + Start *string `form:"start" binding:"required"` + End *string `form:"end" binding:"required"` + } + var rangeScanReq RangeScanReq + if err = c.ShouldBindQuery(&rangeScanReq); err != nil { + WriteError(c, APIMessage{ + Message: err.Error(), + }) + return + } + entries, err = s.core.RangeScan(scanParam.Bucket, *rangeScanReq.Start, *rangeScanReq.End) + if err != nil { + switch err { + case nutsdb.ErrRangeScan: + WriteError(c, ErrRangeScan) + default: + WriteError(c, ErrUnknown) + } + return + } + var res = map[string]string{} + for _, e := range entries { + res[string(e.Key)] = string(e.Value) + } + WriteSucc(c, res) + case GetAll: + entries, err = s.core.GetAll(scanParam.Bucket) + if err != nil { + switch err { + case nutsdb.ErrBucketEmpty: + WriteError(c, ErrBucketEmpty) + default: + WriteError(c, ErrUnknown) + } + return + } + var res = map[string]string{} + for _, e := range entries { + res[string(e.Key)] = string(e.Value) + } + WriteSucc(c, res) + } + + return +} diff --git a/server_zset.go b/server_zset.go new file mode 100644 index 0000000..ec50fbc --- /dev/null +++ b/server_zset.go @@ -0,0 +1,428 @@ +package nutshttp + +import ( + "github.com/gin-gonic/gin" + "github.com/xujiajun/nutsdb/ds/zset" +) + +type Node struct { + Key string `json:"key"` + Value string `json:"value"` +} + +func (s *NutsHTTPServer) ZAdd(c *gin.Context) { + type Params struct { + Score *float64 `json:"score" binding:"required"` + Value string `json:"value" binding:"required"` + } + var ( + err error + baseUri BaseUri + params Params + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + if err = c.ShouldBindJSON(¶ms); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + if err = s.core.zPut(baseUri.Bucket, []byte(baseUri.Key), *params.Score, []byte(params.Value)); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + WriteSucc(c, APIOK) +} + +func (s *NutsHTTPServer) ZCard(c *gin.Context) { + var ( + err error + num int + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if num, err = s.core.zCard(baseUri.Bucket); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + WriteSucc(c, num) +} + +func (s *NutsHTTPServer) ZCount(c *gin.Context) { + type Params struct { + Start float64 `json:"start" binding:"required" form:"start"` + End float64 `json:"end" binding:"required" form:"end"` + Limit int `json:"limit,omitempty" form:"limit"` + ExcludeStart bool `json:"exclude_start,omitempty" form:"exclude_start"` + ExcludeEnd bool `json:"exclude_end,omitempty" form:"exclude_end"` + } + + type Response struct { + Count int `json:"count"` + } + + var ( + count int + err error + baseUri BaseUri + p Params + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if err = c.ShouldBindQuery(&p); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if count, err = s.core.zCount(baseUri.Bucket, p.Start, p.End, &zset.GetByScoreRangeOptions{ + Limit: p.Limit, ExcludeStart: p.ExcludeStart, ExcludeEnd: p.ExcludeEnd}); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + WriteSucc(c, Response{Count: count}) +} + +func (s *NutsHTTPServer) ZGetByKey(c *gin.Context) { + type Response struct { + Node Node `json:"node"` + } + var ( + node *zset.SortedSetNode + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if node, err = s.core.zGetByKey(baseUri.Bucket, baseUri.Key); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + WriteSucc(c, Response{Node{Key: node.Key(), Value: string(node.Value)}}) +} + +func (s *NutsHTTPServer) ZMembers(c *gin.Context) { + + type Response struct { + Nodes []Node `json:"nodes"` + } + + var ( + err error + nodes []*zset.SortedSetNode + baseUri BaseUri + res Response + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if nodes, err = s.core.zMembers(baseUri.Bucket); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + for _, node := range nodes { + res.Nodes = append(res.Nodes, Node{node.Key(), string(node.Value)}) + } + WriteSucc(c, res) +} + +func (s *NutsHTTPServer) ZPeekMax(c *gin.Context) { + type Response struct { + Node Node `json:"node"` + } + var ( + node *zset.SortedSetNode + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if node, err = s.core.zPeekMax(baseUri.Bucket); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + WriteSucc(c, Response{Node{node.Key(), string(node.Value)}}) + +} + +func (s *NutsHTTPServer) ZPeekMin(c *gin.Context) { + type Response struct { + Node Node `json:"node"` + } + var ( + node *zset.SortedSetNode + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if node, err = s.core.zPeekMin(baseUri.Bucket); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + WriteSucc(c, Response{Node{node.Key(), string(node.Value)}}) +} + +func (s *NutsHTTPServer) ZPopMax(c *gin.Context) { + type Response struct { + Node Node `json:"node"` + } + var ( + node *zset.SortedSetNode + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if node, err = s.core.zPopMax(baseUri.Bucket); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + WriteSucc(c, Response{Node{node.Key(), string(node.Value)}}) +} + +func (s *NutsHTTPServer) ZPopMin(c *gin.Context) { + type Response struct { + Nodes Node `json:"nodes"` + } + var ( + node *zset.SortedSetNode + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if node, err = s.core.zPopMin(baseUri.Bucket); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + WriteSucc(c, Response{Node{node.Key(), string(node.Value)}}) +} + +func (s *NutsHTTPServer) ZRangeByRank(c *gin.Context) { + type Response struct { + Nodes []Node `json:"nodes"` + } + type Params struct { + Start int `json:"start" form:"start"` + End int `json:"end" form:"end"` + } + var ( + err error + params Params + reps Response + nodes []*zset.SortedSetNode + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + if err = c.ShouldBindQuery(¶ms); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if nodes, err = s.core.zRangeByRank(baseUri.Bucket, params.Start, params.End); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + for _, node := range nodes { + reps.Nodes = append(reps.Nodes, Node{node.Key(), string(node.Value)}) + } + + WriteSucc(c, reps) +} + +func (s *NutsHTTPServer) ZRangeByScore(c *gin.Context) { + type Params struct { + Start float64 `json:"start" binding:"required" form:"start"` + End float64 `json:"end" binding:"required" form:"end"` + Limit int `json:"limit,omitempty" form:"limit"` + ExcludeStart bool `json:"exclude_start,omitempty" form:"exclude_start"` + ExcludeEnd bool `json:"exclude_end,omitempty" form:"exclude_end"` + } + + type Response struct { + Nodes []Node `json:"nodes"` + } + + var ( + reps Response + err error + nodes []*zset.SortedSetNode + baseUri BaseUri + p Params + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if err = c.ShouldBindQuery(&p); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if nodes, err = s.core.zRangeByScore(baseUri.Bucket, p.Start, p.End, &zset.GetByScoreRangeOptions{ + Limit: p.Limit, ExcludeStart: p.ExcludeStart, ExcludeEnd: p.ExcludeEnd}); err != nil { + WriteError(c, APIMessage{4000, err.Error()}) + return + } + for _, node := range nodes { + reps.Nodes = append(reps.Nodes, Node{node.Key(), string(node.Value)}) + } + + WriteSucc(c, reps) +} + +func (s *NutsHTTPServer) ZRank(c *gin.Context) { + type Response struct { + Rank int `json:"rank"` + } + var ( + rank int + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if rank, err = s.core.zRank(baseUri.Bucket, baseUri.Key); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + WriteSucc(c, Response{Rank: rank}) +} + +func (s *NutsHTTPServer) ZRevRank(c *gin.Context) { + type Response struct { + Rank int `json:"rank"` + } + var ( + rank int + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if rank, err = s.core.zRevRank(baseUri.Bucket, baseUri.Key); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + WriteSucc(c, Response{Rank: rank}) +} + +func (s *NutsHTTPServer) ZRem(c *gin.Context) { + var ( + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if err = s.core.zRem(baseUri.Bucket, baseUri.Key); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + WriteSucc(c, APIOK) +} + +func (s *NutsHTTPServer) ZRemRangeByRank(c *gin.Context) { + type Params struct { + Start int `json:"start" form:"start"` + End int `json:"end" form:"end"` + } + var ( + err error + params Params + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if err = c.ShouldBindQuery(¶ms); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + if err = s.core.ZRemRangeByRank(baseUri.Bucket, params.Start, params.End); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + WriteSucc(c, APIOK) +} + +func (s *NutsHTTPServer) ZScore(c *gin.Context) { + type Response struct { + Score float64 `json:"score"` + } + var ( + score float64 + err error + baseUri BaseUri + ) + + if err = c.ShouldBindUri(&baseUri); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + + if score, err = s.core.zScore(baseUri.Bucket, baseUri.Key); err != nil { + WriteError(c, APIMessage{Message: err.Error()}) + return + } + WriteSucc(c, Response{Score: score}) +}