Skip to content

Commit 162b33f

Browse files
author
Mikhail Podtserkovskiy
committed
QA-7710: refactoring part 2
1 parent 52e6834 commit 162b33f

File tree

8 files changed

+92
-87
lines changed

8 files changed

+92
-87
lines changed

‎pool/node.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ type Node struct {
2929
}
3030

3131
func (n *Node) String() string {
32-
return "Node [" + n.Address + "]"
32+
return "Node [" + n.Key + "]"
3333
}
3434

3535
func NewNode(

‎pool/pool.go‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -148,7 +148,7 @@ func (p *Pool) FixNodeStatuses() {
148148
continue
149149
}
150150
if isFixed {
151-
log.Infof("Node [%s] status fixed", node.Address)
151+
log.Infof("Node [%s] status fixed", node.Key)
152152
}
153153
}
154154
}
@@ -169,7 +169,7 @@ func (p *Pool) fixNodeStatus(node *Node) (bool, error) {
169169
}
170170
err := p.strategyList.FixNodeStatus(*node)
171171
if err != nil {
172-
return false, fmt.Errorf("Can't fix node [%s] status, %s", node.Address, err.Error())
172+
return false, fmt.Errorf("Can't fix node [%s] status, %s", node.Key, err.Error())
173173
}
174174
return true, nil
175175
}

‎proxy/transport.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@ func (t *CreateSessionTransport) RoundTrip(request *http.Request) (*http.Respons
6161
err = fmt.Errorf("session not created, response: %s", string(b))
6262
return nil, err
6363
}
64-
log.Infof("register SessionID: %s on node %s", sessionID, t.node.Address)
64+
log.Infof("register SessionID: %s on node %s", sessionID, t.node.Key)
6565
err = t.pool.RegisterSession(t.node, sessionID)
6666
if err != nil {
6767
err = fmt.Errorf("sessionId not registred in storage: %s", sessionID)

‎storage/local/local_test.go‎

Lines changed: 31 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -15,137 +15,137 @@ func TestStorage_Add_Positive(t *testing.T) {
1515
}
1616

1717
func TestStorage_Add_Positive_Repeat(t *testing.T) {
18-
s := Storage{db: map[string]*pool.Node{"1": {Address: "1"}}}
19-
err := s.Add(pool.Node{Address: "1"}, 0)
18+
s := Storage{db: map[string]*pool.Node{"1": {Key: "1"}}}
19+
err := s.Add(pool.Node{Key: "1"}, 0)
2020
assert.NoError(t, err)
2121
assert.Len(t, s.db, 1)
2222
}
2323

2424
func TestStorage_Add_Negative_LimitReached(t *testing.T) {
25-
s := Storage{db: map[string]*pool.Node{"1": {Address: "1"}}}
25+
s := Storage{db: map[string]*pool.Node{"1": {Key: "1"}}}
2626
limit := 1
27-
err := s.Add(pool.Node{Address: "2"}, limit)
27+
err := s.Add(pool.Node{Key: "2"}, limit)
2828
assert.Error(t, err, "limit reached")
2929
assert.Len(t, s.db, limit)
3030
}
3131

3232
func TestStorage_ReserveAvailable_Positive(t *testing.T) {
33-
expectedNode := pool.Node{Address: "1", Status: pool.NodeStatusAvailable}
34-
s := Storage{db: map[string]*pool.Node{expectedNode.Address: &expectedNode}}
33+
expectedNode := pool.Node{Key: "1", Status: pool.NodeStatusAvailable}
34+
s := Storage{db: map[string]*pool.Node{expectedNode.Key: &expectedNode}}
3535
node, err := s.ReserveAvailable([]pool.Node{expectedNode})
3636
assert.NoError(t, err)
3737
assert.Equal(t, expectedNode, node)
38-
assert.Equal(t, pool.NodeStatusReserved, s.db[node.Address].Status)
38+
assert.Equal(t, pool.NodeStatusReserved, s.db[node.Key].Status)
3939
}
4040

4141
func TestStorage_ReserveAvailable_Negative_NotFoundAvailableNodes(t *testing.T) {
42-
expectedNode := pool.Node{Address: "1", Status: pool.NodeStatusBusy}
43-
s := Storage{db: map[string]*pool.Node{expectedNode.Address: &expectedNode}}
42+
expectedNode := pool.Node{Key: "1", Status: pool.NodeStatusBusy}
43+
s := Storage{db: map[string]*pool.Node{expectedNode.Key: &expectedNode}}
4444
_, err := s.ReserveAvailable([]pool.Node{expectedNode})
4545
assert.Error(t, err, storage.ErrNotFound)
4646
}
4747

4848
func TestStorage_ReserveAvailable_Negative_InvalidNodeList(t *testing.T) {
4949
s := Storage{db: map[string]*pool.Node{}}
50-
_, err := s.ReserveAvailable([]pool.Node{{Address: "awd"}})
50+
_, err := s.ReserveAvailable([]pool.Node{{Key: "awd"}})
5151
assert.Error(t, err, storage.ErrNotFound)
5252
}
5353

5454
func TestStorage_SetBusy_Positive(t *testing.T) {
55-
expectedNode := pool.Node{Address: "1"}
56-
s := Storage{db: map[string]*pool.Node{expectedNode.Address: &expectedNode}}
55+
expectedNode := pool.Node{Key: "1"}
56+
s := Storage{db: map[string]*pool.Node{expectedNode.Key: &expectedNode}}
5757
expectedSessionID := "expectedSessionID"
5858
err := s.SetBusy(expectedNode, expectedSessionID)
5959
assert.NoError(t, err)
60-
assert.Equal(t, pool.NodeStatusBusy, s.db[expectedNode.Address].Status)
61-
assert.Equal(t, expectedSessionID, s.db[expectedNode.Address].SessionID)
60+
assert.Equal(t, pool.NodeStatusBusy, s.db[expectedNode.Key].Status)
61+
assert.Equal(t, expectedSessionID, s.db[expectedNode.Key].SessionID)
6262
}
6363

6464
func TestStorage_SetBusy_Negative(t *testing.T) {
65-
expectedNode := pool.Node{Address: "1"}
65+
expectedNode := pool.Node{Key: "1"}
6666
s := Storage{db: map[string]*pool.Node{}}
6767
expectedSessionID := "expectedSessionID"
6868
err := s.SetBusy(expectedNode, expectedSessionID)
6969
assert.Error(t, err, storage.ErrNotFound)
7070
}
7171

7272
func TestStorage_SetAvailable_Positive(t *testing.T) {
73-
expectedNode := pool.Node{Address: "1"}
74-
s := Storage{db: map[string]*pool.Node{expectedNode.Address: &expectedNode}}
73+
expectedNode := pool.Node{Key: "1"}
74+
s := Storage{db: map[string]*pool.Node{expectedNode.Key: &expectedNode}}
7575
err := s.SetAvailable(expectedNode)
7676
assert.NoError(t, err)
77-
assert.Equal(t, pool.NodeStatusAvailable, s.db[expectedNode.Address].Status)
77+
assert.Equal(t, pool.NodeStatusAvailable, s.db[expectedNode.Key].Status)
7878
}
7979

8080
func TestStorage_SetAvailable_Negative(t *testing.T) {
81-
expectedNode := pool.Node{Address: "1"}
81+
expectedNode := pool.Node{Key: "1"}
8282
s := Storage{db: map[string]*pool.Node{}}
8383
err := s.SetAvailable(expectedNode)
8484
assert.Error(t, err, storage.ErrNotFound)
8585
}
8686

8787
func TestStorage_GetCountWithStatus_Positive_All(t *testing.T) {
88-
s := Storage{db: map[string]*pool.Node{"1": {Address: "1"}, "2": {Address: "2"}}}
88+
s := Storage{db: map[string]*pool.Node{"1": {Key: "1"}, "2": {Key: "2"}}}
8989
count, err := s.GetCountWithStatus(nil)
9090
assert.NoError(t, err)
9191
assert.Equal(t, count, len(s.db))
9292
}
9393

9494
func TestStorage_GetCountWithStatus_Positive_One(t *testing.T) {
9595
expectedStatus := pool.NodeStatusBusy
96-
s := Storage{db: map[string]*pool.Node{"1": {Address: "1", Status: expectedStatus}, "2": {Address: "2"}}}
96+
s := Storage{db: map[string]*pool.Node{"1": {Key: "1", Status: expectedStatus}, "2": {Key: "2"}}}
9797
count, err := s.GetCountWithStatus(&expectedStatus)
9898
assert.NoError(t, err)
9999
assert.Equal(t, count, 1)
100100
}
101101

102102
func TestStorage_GetBySession_Positive(t *testing.T) {
103-
expectedNode := pool.Node{Address: "1"}
104-
s := Storage{db: map[string]*pool.Node{expectedNode.Address: &expectedNode}}
103+
expectedNode := pool.Node{Key: "1"}
104+
s := Storage{db: map[string]*pool.Node{expectedNode.Key: &expectedNode}}
105105
node, err := s.GetBySession(expectedNode.SessionID)
106106
assert.NoError(t, err)
107107
assert.Equal(t, expectedNode, node)
108108
}
109109

110110
func TestStorage_GetBySession_Negative(t *testing.T) {
111-
expectedNode := pool.Node{Address: "1"}
111+
expectedNode := pool.Node{Key: "1"}
112112
s := Storage{db: map[string]*pool.Node{}}
113113
_, err := s.GetBySession(expectedNode.SessionID)
114114
assert.Error(t, err, storage.ErrNotFound)
115115
}
116116

117117
func TestStorage_GetByAddress_Positive(t *testing.T) {
118-
expectedNode := pool.Node{Address: "1"}
119-
s := Storage{db: map[string]*pool.Node{expectedNode.Address: &expectedNode}}
118+
expectedNode := pool.Node{Address: "1", Key: "12d"}
119+
s := Storage{db: map[string]*pool.Node{expectedNode.Key: &expectedNode}}
120120
node, err := s.GetByAddress(expectedNode.Address)
121121
assert.NoError(t, err)
122122
assert.Equal(t, expectedNode, node)
123123
}
124124

125125
func TestStorage_GetByAddress_Negative(t *testing.T) {
126-
expectedNode := pool.Node{Address: "1"}
126+
expectedNode := pool.Node{Address: "1", Key: "1234567890"}
127127
s := Storage{db: map[string]*pool.Node{}}
128128
_, err := s.GetByAddress(expectedNode.Address)
129129
assert.Error(t, err, storage.ErrNotFound)
130130
}
131131

132132
func TestStorage_GetAll_Positive(t *testing.T) {
133-
s := Storage{db: map[string]*pool.Node{"1": {Address: "1"}, "2": {Address: "2"}}}
133+
s := Storage{db: map[string]*pool.Node{"1": {Key: "1"}, "2": {Key: "2"}}}
134134
nodeList, err := s.GetAll()
135135
assert.NoError(t, err)
136136
assert.Len(t, nodeList, 2)
137137
}
138138

139139
func TestStorage_Remove_Positive(t *testing.T) {
140-
node := pool.Node{Address: "1"}
141-
s := Storage{db: map[string]*pool.Node{node.Address: &node}}
140+
node := pool.Node{Key: "1"}
141+
s := Storage{db: map[string]*pool.Node{node.Key: &node}}
142142
err := s.Remove(node)
143143
assert.NoError(t, err)
144144
}
145145

146146
func TestStorage_Remove_Negative(t *testing.T) {
147147
s := Storage{db: map[string]*pool.Node{}}
148-
node := pool.Node{Address: "1"}
148+
node := pool.Node{Key: "1"}
149149
err := s.Remove(node)
150150
assert.Error(t, err, storage.ErrNotFound)
151151
}

‎storage/local/storage.go‎

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -28,15 +28,15 @@ func (s *Storage) Add(node pool.Node, limit int) error {
2828
}
2929
}
3030

31-
s.db[node.Address] = &node
31+
s.db[node.Key] = &node
3232
return nil
3333
}
3434

3535
func (s *Storage) ReserveAvailable(nodeList []pool.Node) (pool.Node, error) {
3636
s.mu.Lock()
3737
defer s.mu.Unlock()
3838
for _, node := range nodeList {
39-
dbNode, ok := s.db[node.Address]
39+
dbNode, ok := s.db[node.Key]
4040
if ok && dbNode.Status == pool.NodeStatusAvailable {
4141
dbNode.Status = pool.NodeStatusReserved
4242
dbNode.Updated = time.Now().Unix()
@@ -49,7 +49,7 @@ func (s *Storage) ReserveAvailable(nodeList []pool.Node) (pool.Node, error) {
4949
func (s *Storage) SetBusy(node pool.Node, sessionID string) error {
5050
s.mu.Lock()
5151
defer s.mu.Unlock()
52-
storedNode, ok := s.db[node.Address]
52+
storedNode, ok := s.db[node.Key]
5353
if !ok {
5454
return storage.ErrNotFound
5555
}
@@ -62,7 +62,7 @@ func (s *Storage) SetBusy(node pool.Node, sessionID string) error {
6262
func (s *Storage) SetAvailable(node pool.Node) error {
6363
s.mu.Lock()
6464
defer s.mu.Unlock()
65-
storedNode, ok := s.db[node.Address]
65+
storedNode, ok := s.db[node.Key]
6666
if !ok {
6767
return storage.ErrNotFound
6868
}
@@ -100,11 +100,12 @@ func (s *Storage) GetBySession(sessionID string) (pool.Node, error) {
100100
func (s *Storage) GetByAddress(address string) (pool.Node, error) {
101101
s.mu.RLock()
102102
defer s.mu.RUnlock()
103-
node, ok := s.db[address]
104-
if !ok {
105-
return pool.Node{}, storage.ErrNotFound
103+
for _, node := range s.db {
104+
if node.Address == address {
105+
return *node, nil
106+
}
106107
}
107-
return *node, nil
108+
return pool.Node{}, storage.ErrNotFound
108109
}
109110

110111
func (s *Storage) GetAll() ([]pool.Node, error) {
@@ -121,10 +122,10 @@ func (s *Storage) GetAll() ([]pool.Node, error) {
121122
func (s *Storage) Remove(node pool.Node) error {
122123
s.mu.Lock()
123124
defer s.mu.Unlock()
124-
_, ok := s.db[node.Address]
125+
_, ok := s.db[node.Key]
125126
if !ok {
126127
return storage.ErrNotFound
127128
}
128-
delete(s.db, node.Address)
129+
delete(s.db, node.Key)
129130
return nil
130131
}

‎storage/migrations/mysql/20180417152820-add_unique_key.sql‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
11

22
-- +migrate Up
33
ALTER TABLE `node` ADD COLUMN `key` varchar(255) NOT NULL AFTER `id`;
4+
ALTER TABLE `capabilities` CHANGE COLUMN `nodeAddress` `nodeKey` VARCHAR(255) NOT NULL;
5+
CREATE UNIQUE INDEX `key` ON `node` (`key`);
46

57
-- +migrate Down
68
SIGNAL SQLSTATE '45000' SET message_text = 'Impossible down this migration';

0 commit comments

Comments
 (0)