Debian Codegraph @

backend/etcd/etcd.go

raw ◀ ▶
Source reconstructed at patch state 0 of 1 — not the installed (fully patched) source.
1 Debian patch touch this file
1 package etcd
2
3 import (
4 "context"
5 "errors"
6 "fmt"
7 "time"
8
9 "github.com/xordataexchange/crypt/backend"
10
11 goetcd "github.com/coreos/etcd/client"
12 )
13
14 type Client struct {
15 client goetcd.Client
16 keysAPI goetcd.KeysAPI
17 waitIndex uint64
18 }
19
20 func New(machines []string) (*Client, error) {
21 newClient, err := goetcd.New(goetcd.Config{
22 Endpoints: machines,
23 })
24 if err != nil {
25 return nil, fmt.Errorf("creating new etcd client for crypt.backend.Client: %v", err)
26 }
27 keysAPI := goetcd.NewKeysAPI(newClient)
28 return &Client{client: newClient, keysAPI: keysAPI, waitIndex: 0}, nil
29 }
30
31 func (c *Client) Get(key string) ([]byte, error) {
32 return c.GetWithContext(context.TODO(), key)
33 }
34
35 func (c *Client) GetWithContext(ctx context.Context, key string) ([]byte, error) {
36 resp, err := c.keysAPI.Get(ctx, key, nil)
37 if err != nil {
38 return nil, err
39 }
40 return []byte(resp.Node.Value), nil
41 }
42
43 func addKVPairs(node *goetcd.Node, list backend.KVPairs) backend.KVPairs {
44 if node.Dir {
45 for _, n := range node.Nodes {
46 list = addKVPairs(n, list)
47 }
48 return list
49 }
50 return append(list, &backend.KVPair{Key: node.Key, Value: []byte(node.Value)})
51 }
52
53 func (c *Client) List(key string) (backend.KVPairs, error) {
54 return c.ListWithContext(context.TODO(), key)
55 }
56
57 func (c *Client) ListWithContext(ctx context.Context, key string) (backend.KVPairs, error) {
58 resp, err := c.keysAPI.Get(ctx, key, nil)
59 if err != nil {
60 return nil, err
61 }
62 if !resp.Node.Dir {
63 return nil, errors.New("key is not a directory")
64 }
65 list := addKVPairs(resp.Node, nil)
66 return list, nil
67 }
68
69 func (c *Client) Set(key string, value []byte) error {
70 return c.SetWithContext(context.TODO(), key, value)
71 }
72
73 func (c *Client) SetWithContext(ctx context.Context, key string, value []byte) error {
74 _, err := c.keysAPI.Set(ctx, key, string(value), nil)
75 return err
76 }
77
78 func (c *Client) Watch(key string, stop chan bool) <-chan *backend.Response {
79 return c.WatchWithContext(context.Background(), key, stop)
80 }
81
82 func (c *Client) WatchWithContext(ctx context.Context, key string, stop chan bool) <-chan *backend.Response {
83 respChan := make(chan *backend.Response, 0)
84 go func() {
85 watcher := c.keysAPI.Watcher(key, nil)
86 ctx, cancel := context.WithCancel(ctx)
87 go func() {
88 <-stop
89 cancel()
90 }()
91 for {
92 var resp *goetcd.Response
93 var err error
94 // if c.waitIndex == 0 {
95 // resp, err = c.client.Get(key, false, false)
96 // if err != nil {
97 // respChan <- &backend.Response{nil, err}
98 // time.Sleep(time.Second * 5)
99 // continue
100 // }
101 // c.waitIndex = resp.EtcdIndex
102 // respChan <- &backend.Response{[]byte(resp.Node.Value), nil}
103 // }
104 // resp, err = c.client.Watch(key, c.waitIndex+1, false, nil, stop)
105 resp, err = watcher.Next(ctx)
106 if err != nil {
107 respChan <- &backend.Response{nil, err}
108 time.Sleep(time.Second * 5)
109 continue
110 }
111 c.waitIndex = resp.Node.ModifiedIndex
112 respChan <- &backend.Response{[]byte(resp.Node.Value), nil}
113 }
114 }()
115 return respChan
116 }