1
=== added directory 'worker/peergrouper'
2
=== added file 'worker/peergrouper/desired.go'
3
--- worker/peergrouper/desired.go	1970-01-01 00:00:00 +0000
4
+++ worker/peergrouper/desired.go	2014-02-14 12:14:58 +0000
5
@@ -0,0 +1,290 @@
6
1
package peergrouper
7
2
8
3
import (
9
4
	"fmt"
10
5
	"sort"
11
6
12
7
	"launchpad.net/juju-core/replicaset"
13
8
	"launchpad.net/loggo"
14
9
)
15
10
16
11
var logger = loggo.GetLogger("juju.worker.peergrouper")
17
12
18
13
// peerGroupInfo holds information that may contribute to
19
14
// a peer group.
20
15
type peerGroupInfo struct {
21
16
	machines []*machine // possibly map[id] *machine
22
17
	statuses []replicaset.MemberStatus
23
18
	members  []replicaset.Member
24
19
}
25
20
26
21
// machine represents a machine in State.
27
22
type machine struct {
28
23
	id        string
29
24
	wantsVote bool
30
25
	hostPort  string
31
26
}
32
27
33
28
// desiredPeerGroup returns the mongo peer group according to the given
34
29
// servers and a map with an element for each machine in info.machines
35
30
// specifying whether that machine has been configured as voting. It may
36
31
// return (nil, nil, nil) if the current group is already correct.
37
32
func desiredPeerGroup(info *peerGroupInfo) ([]replicaset.Member, map[*machine]bool, error) {
38
33
	changed := false
39
34
	members, extra, maxId := info.membersMap()
40
35
41
36
	// We may find extra peer group members if the machines
42
37
	// have been removed or their state server status removed.
43
38
	// This should only happen if they had been set to non-voting
44
39
	// before removal, in which case we want to remove it
45
40
	// from the members list. If we find a member that's still configured
46
41
	// to vote, it's an error.
47
42
	// TODO There are some other possibilities
48
43
	// for what to do in that case.
49
44
	// 1) leave them untouched, but deal
50
45
	// with others as usual "i didn't see that bit"
51
46
	// 2) leave them untouched, deal with others,
52
47
	// but make sure the extras aren't eligible to
53
48
	// be primary.
54
49
	// 3) remove them "get rid of bad rubbish"
55
50
	// 4) bomb out "run in circles, scream and shout"
56
51
	// 5) do nothing "nothing to see here"
57
52
	for _, member := range extra {
58
53
		if member.Votes == nil || *member.Votes > 0 {
59
54
			return nil, nil, fmt.Errorf("voting non-machine member found in peer group")
60
55
		}
61
56
		changed = true
62
57
	}
63
58
64
59
	toRemoveVote, toAddVote, toKeep := possiblePeerGroupChanges(info, members)
65
60
66
61
	// Set up initial record of machine votes. Any changes after
67
62
	// this will trigger a peer group election.
68
63
	machineVoting := make(map[*machine]bool)
69
64
	for _, m := range info.machines {
70
65
		if member := members[m]; member != nil && isVotingMember(member) {
71
66
			machineVoting[m] = true
72
67
		}
73
68
	}
74
69
	setVoting := func(m *machine, voting bool) {
75
70
		setMemberVoting(members[m], voting)
76
71
		machineVoting[m] = voting
77
72
		changed = true
78
73
	}
79
74
	adjustVotes(toRemoveVote, toAddVote, setVoting)
80
75
81
76
	addNewMembers(members, toKeep, maxId, setVoting)
82
77
	if updateAddresses(members, info.machines) {
83
78
		changed = true
84
79
	}
85
80
	if !changed {
86
81
		return nil, nil, nil
87
82
	}
88
83
	var memberSet []replicaset.Member
89
84
	for _, member := range members {
90
85
		memberSet = append(memberSet, *member)
91
86
	}
92
87
	return memberSet, machineVoting, nil
93
88
}
94
89
95
90
func isVotingMember(member *replicaset.Member) bool {
96
91
	return member.Votes == nil || *member.Votes > 0
97
92
}
98
93
99
94
// possiblePeerGroupChanges returns a set of slices
100
95
// classifying all the existing machines according to
101
96
// how their vote might move.
102
97
// toRemoveVote holds machines whose vote should
103
98
// be removed; toAddVote holds machines which are
104
99
// ready to vote; toKeep holds machines with no desired
105
100
// change to their voting status (this includes machines
106
101
// that are not yet represented in the peer group).
107
102
func possiblePeerGroupChanges(
108
103
	info *peerGroupInfo,
109
104
	members map[*machine]*replicaset.Member,
110
105
) (toRemoveVote, toAddVote, toKeep []*machine) {
111
106
	statuses := info.statusesMap(members)
112
107
113
108
	for _, m := range info.machines {
114
109
		member := members[m]
115
110
		isVoting := member != nil && isVotingMember(member)
116
111
		switch {
117
112
		case m.wantsVote && isVoting:
118
113
			toKeep = append(toKeep, m)
119
114
		case m.wantsVote && !isVoting:
120
115
			if status, ok := statuses[m]; ok && isReady(status) {
121
116
				toAddVote = append(toAddVote, m)
122
117
			} else {
123
118
				toKeep = append(toKeep, m)
124
119
			}
125
120
		case !m.wantsVote && isVoting:
126
121
			toRemoveVote = append(toRemoveVote, m)
127
122
		case !m.wantsVote && !isVoting:
128
123
			toKeep = append(toKeep, m)
129
124
		}
130
125
	}
131
126
	// sort machines to be added and removed so that we
132
127
	// get deterministic behaviour when testing. Earlier
133
128
	// entries will be dealt with preferentially, so we could
134
129
	// potentially sort by some other metric in each case.
135
130
	sort.Sort(byId(toRemoveVote))
136
131
	sort.Sort(byId(toAddVote))
137
132
	sort.Sort(byId(toKeep))
138
133
	return toRemoveVote, toAddVote, toKeep
139
134
}
140
135
141
136
// updateAddresses updates the members' addresses from the machines' addresses.
142
137
// It reports whether any changes have been made.
143
138
func updateAddresses(members map[*machine]*replicaset.Member, machines []*machine) bool {
144
139
	changed := false
145
140
	// Make sure all members' machine addresses are up to date.
146
141
	for _, m := range machines {
147
142
		if m.hostPort == "" {
148
143
			continue
149
144
		}
150
145
		// TODO ensure that replicaset works correctly with IPv6 [host]:port addresses.
151
146
		if m.hostPort != members[m].Address {
152
147
			members[m].Address = m.hostPort
153
148
			changed = true
154
149
		}
155
150
	}
156
151
	return changed
157
152
}
158
153
159
154
// adjustVotes adjusts the votes of the given machines, taking
160
155
// care not to let the total number of votes become even at
161
156
// any time. It calls setVoting to change the voting status
162
157
// of a machine.
163
158
func adjustVotes(toRemoveVote, toAddVote []*machine, setVoting func(*machine, bool)) {
164
159
	// Remove voting members if they can be replaced by
165
160
	// candidates that are ready. This does not affect
166
161
	// the total number of votes.
167
162
	nreplace := min(len(toRemoveVote), len(toAddVote))
168
163
	for i := 0; i < nreplace; i++ {
169
164
		from := toRemoveVote[i]
170
165
		to := toAddVote[i]
171
166
		setVoting(from, false)
172
167
		setVoting(to, true)
173
168
	}
174
169
	toAddVote = toAddVote[nreplace:]
175
170
	toRemoveVote = toRemoveVote[nreplace:]
176
171
177
172
	// At this point, one or both of toAdd or toRemove is empty, so
178
173
	// we can adjust the voting-member count by an even delta,
179
174
	// maintaining the invariant that the total vote count is odd.
180
175
	if len(toAddVote) > 0 {
181
176
		toAddVote = toAddVote[0 : len(toAddVote)-len(toAddVote)%2]
182
177
		for _, m := range toAddVote {
183
178
			setVoting(m, true)
184
179
		}
185
180
	} else {
186
181
		toRemoveVote = toRemoveVote[0 : len(toRemoveVote)-len(toRemoveVote)%2]
187
182
		for _, m := range toRemoveVote {
188
183
			setVoting(m, false)
189
184
		}
190
185
	}
191
186
}
192
187
193
188
// addNewMembers adds new members from toKeep
194
189
// to the given set of members, allocating ids from
195
190
// maxId upwards. It calls setVoting to set the voting
196
191
// status of each new member.
197
192
func addNewMembers(
198
193
	members map[*machine]*replicaset.Member,
199
194
	toKeep []*machine,
200
195
	maxId int,
201
196
	setVoting func(*machine, bool),
202
197
) {
203
198
	for _, m := range toKeep {
204
199
		if members[m] == nil && m.hostPort != "" {
205
200
			// This machine was not previously in the members list,
206
201
			// so add it (as non-voting). We maintain the
207
202
			// id manually to make it easier for tests.
208
203
			maxId++
209
204
			member := &replicaset.Member{
210
205
				Tags: map[string]string{
211
206
					"juju-machine-id": m.id,
212
207
				},
213
208
				Id: maxId,
214
209
			}
215
210
			members[m] = member
216
211
			setVoting(m, false)
217
212
		}
218
213
	}
219
214
}
220
215
221
216
func isReady(status replicaset.MemberStatus) bool {
222
217
	return status.Healthy && (status.State == replicaset.PrimaryState ||
223
218
		status.State == replicaset.SecondaryState)
224
219
}
225
220
226
221
func setMemberVoting(member *replicaset.Member, voting bool) {
227
222
	if voting {
228
223
		member.Votes = nil
229
224
		member.Priority = nil
230
225
	} else {
231
226
		votes := 0
232
227
		member.Votes = &votes
233
228
		priority := 0.0
234
229
		member.Priority = &priority
235
230
	}
236
231
}
237
232
238
233
type byId []*machine
239
234
240
235
func (l byId) Len() int           { return len(l) }
241
236
func (l byId) Swap(i, j int)      { l[i], l[j] = l[j], l[i] }
242
237
func (l byId) Less(i, j int) bool { return l[i].id < l[j].id }
243
238
244
239
// membersMap returns the replica-set members inside info keyed
245
240
// by machine. Any members that do not have a corresponding
246
241
// machine are returned in extra.
247
242
// The maximum replica-set id is returned in maxId.
248
243
func (info *peerGroupInfo) membersMap() (members map[*machine]*replicaset.Member, extra []replicaset.Member, maxId int) {
249
244
	maxId = -1
250
245
	members = make(map[*machine]*replicaset.Member)
251
246
	for _, member := range info.members {
252
247
		member := member
253
248
		var found *machine
254
249
		if mid, ok := member.Tags["juju-machine-id"]; ok {
255
250
			for _, m := range info.machines {
256
251
				if m.id == mid {
257
252
					found = m
258
253
					break
259
254
				}
260
255
			}
261
256
		}
262
257
		if found != nil {
263
258
			members[found] = &member
264
259
		} else {
265
260
			extra = append(extra, member)
266
261
		}
267
262
		if member.Id > maxId {
268
263
			maxId = member.Id
269
264
		}
270
265
	}
271
266
	return members, extra, maxId
272
267
}
273
268
274
269
// statusesMap returns the statuses inside info keyed by machine.
275
270
// The provided members map holds the members keyed by machine,
276
271
// as returned by membersMap.
277
272
func (info *peerGroupInfo) statusesMap(members map[*machine]*replicaset.Member) map[*machine]replicaset.MemberStatus {
278
273
	statuses := make(map[*machine]replicaset.MemberStatus)
279
274
	for _, status := range info.statuses {
280
275
		for m, member := range members {
281
276
			if member.Id == status.Id {
282
277
				statuses[m] = status
283
278
				break
284
279
			}
285
280
		}
286
281
	}
287
282
	return statuses
288
283
}
289
284
290
285
func min(i, j int) int {
291
286
	if i < j {
292
287
		return i
293
288
	}
294
289
	return j
295
290
}
296
0
291
297
=== added file 'worker/peergrouper/desired_test.go'
298
--- worker/peergrouper/desired_test.go	1970-01-01 00:00:00 +0000
299
+++ worker/peergrouper/desired_test.go	2014-02-14 12:14:58 +0000
300
@@ -0,0 +1,358 @@
301
1
package peergrouper
302
2
303
3
import (
304
4
	"fmt"
305
5
	"sort"
306
6
	"strconv"
307
7
	"strings"
308
8
	stdtesting "testing"
309
9
310
10
	gc "launchpad.net/gocheck"
311
11
	"launchpad.net/juju-core/replicaset"
312
12
	jc "launchpad.net/juju-core/testing/checkers"
313
13
	"launchpad.net/juju-core/testing/testbase"
314
14
)
315
15
316
16
func TestPackage(t *stdtesting.T) {
317
17
	gc.TestingT(t)
318
18
}
319
19
320
20
type desiredPeerGroupSuite struct {
321
21
	testbase.LoggingSuite
322
22
}
323
23
324
24
var _ = gc.Suite(&desiredPeerGroupSuite{})
325
25
326
26
const mongoPort = 1234
327
27
328
28
var desiredPeerGroupTests = []struct {
329
29
	about    string
330
30
	machines []*machine
331
31
	statuses []replicaset.MemberStatus
332
32
	members  []replicaset.Member
333
33
334
34
	expectMembers []replicaset.Member
335
35
	expectVoting  []bool
336
36
	expectErr     string
337
37
}{{
338
38
	about:         "single machine, no change",
339
39
	machines:      mkMachines("11v"),
340
40
	members:       mkMembers("1v"),
341
41
	statuses:      mkStatuses("1p"),
342
42
	expectVoting:  []bool{true},
343
43
	expectMembers: nil,
344
44
}, {
345
45
	about:        "extra member with nil Vote",
346
46
	machines:     mkMachines("11v"),
347
47
	members:      mkMembers("1v 2vT"),
348
48
	statuses:     mkStatuses("1p 2s"),
349
49
	expectVoting: []bool{true},
350
50
	expectErr:    "voting non-machine member found in peer group",
351
51
}, {
352
52
	about:    "extra member with >1 votes",
353
53
	machines: mkMachines("11v"),
354
54
	members: append(mkMembers("1v"), replicaset.Member{
355
55
		Id:      2,
356
56
		Votes:   newInt(2),
357
57
		Address: "0.1.2.12:1234",
358
58
	}),
359
59
	statuses:     mkStatuses("1p 2s"),
360
60
	expectVoting: []bool{true},
361
61
	expectErr:    "voting non-machine member found in peer group",
362
62
}, {
363
63
	about:         "new machine with no associated member",
364
64
	machines:      mkMachines("11v 12v"),
365
65
	members:       mkMembers("1v"),
366
66
	statuses:      mkStatuses("1p"),
367
67
	expectVoting:  []bool{true, false},
368
68
	expectMembers: mkMembers("1v 2"),
369
69
}, {
370
70
	about:         "one machine has become ready to vote  (-> no change)",
371
71
	machines:      mkMachines("11v 12v"),
372
72
	members:       mkMembers("1v 2"),
373
73
	statuses:      mkStatuses("1p 2s"),
374
74
	expectVoting:  []bool{true, false},
375
75
	expectMembers: nil,
376
76
}, {
377
77
	about:         "two machines have become ready to vote (-> added)",
378
78
	machines:      mkMachines("11v 12v 13v"),
379
79
	members:       mkMembers("1v 2 3"),
380
80
	statuses:      mkStatuses("1p 2s 3s"),
381
81
	expectVoting:  []bool{true, true, true},
382
82
	expectMembers: mkMembers("1v 2v 3v"),
383
83
}, {
384
84
	about:         "two machines have become ready to vote but one is not healthy (-> no change)",
385
85
	machines:      mkMachines("11v 12v 13v"),
386
86
	members:       mkMembers("1v 2 3"),
387
87
	statuses:      mkStatuses("1p 2s 3sH"),
388
88
	expectVoting:  []bool{true, false, false},
389
89
	expectMembers: nil,
390
90
}, {
391
91
	about:         "three machines have become ready to vote (-> 2 added)",
392
92
	machines:      mkMachines("11v 12v 13v 14v"),
393
93
	members:       mkMembers("1v 2 3 4"),
394
94
	statuses:      mkStatuses("1p 2s 3s 4s"),
395
95
	expectVoting:  []bool{true, true, true, false},
396
96
	expectMembers: mkMembers("1v 2v 3v 4"),
397
97
}, {
398
98
	about:         "one machine ready to lose vote with no others -> no change",
399
99
	machines:      mkMachines("11"),
400
100
	members:       mkMembers("1v"),
401
101
	statuses:      mkStatuses("1p"),
402
102
	expectVoting:  []bool{true},
403
103
	expectMembers: nil,
404
104
}, {
405
105
	about:         "two machines ready to lose vote -> votes removed",
406
106
	machines:      mkMachines("11 12v 13"),
407
107
	members:       mkMembers("1v 2v 3v"),
408
108
	statuses:      mkStatuses("1p 2p 3p"),
409
109
	expectVoting:  []bool{false, true, false},
410
110
	expectMembers: mkMembers("1 2v 3"),
411
111
}, {
412
112
	about:         "machines removed as state server -> removed from members",
413
113
	machines:      mkMachines("11v"),
414
114
	members:       mkMembers("1v 2 3"),
415
115
	statuses:      mkStatuses("1p 2s 3s"),
416
116
	expectVoting:  []bool{true},
417
117
	expectMembers: mkMembers("1v"),
418
118
}, {
419
119
	about:         "a candidate can take the vote of a non-candidate when they're ready",
420
120
	machines:      mkMachines("11v 12v 13 14v"),
421
121
	members:       mkMembers("1v 2v 3v 4"),
422
122
	statuses:      mkStatuses("1p 2s 3s 4s"),
423
123
	expectVoting:  []bool{true, true, false, true},
424
124
	expectMembers: mkMembers("1v 2v 3 4v"),
425
125
}, {
426
126
	about:         "several candidates can take non-candidates' votes",
427
127
	machines:      mkMachines("11v 12v 13 14 15 16v 17v 18v"),
428
128
	members:       mkMembers("1v 2v 3v 4v 5v 6 7 8"),
429
129
	statuses:      mkStatuses("1p 2s 3s 4s 5s 6s 7s 8s"),
430
130
	expectVoting:  []bool{true, true, false, false, false, true, true, true},
431
131
	expectMembers: mkMembers("1v 2v 3 4 5 6v 7v 8v"),
432
132
}, {
433
133
	about: "a changed machine address should propagate to the members",
434
134
	machines: append(mkMachines("11v 12v"), &machine{
435
135
		id:        "13",
436
136
		wantsVote: true,
437
137
		hostPort:  "0.1.99.13:1234",
438
138
	}),
439
139
	statuses:     mkStatuses("1s 2p 3p"),
440
140
	members:      mkMembers("1v 2v 3v"),
441
141
	expectVoting: []bool{true, true, true},
442
142
	expectMembers: append(mkMembers("1v 2v"), replicaset.Member{
443
143
		Id:      3,
444
144
		Address: "0.1.99.13:1234",
445
145
		Tags:    memberTag("13"),
446
146
	}),
447
147
}}
448
148
449
149
func (*desiredPeerGroupSuite) TestDesiredPeerGroup(c *gc.C) {
450
150
	for i, test := range desiredPeerGroupTests {
451
151
		c.Logf("\ntest %d: %s", i, test.about)
452
152
		info := &peerGroupInfo{
453
153
			machines: test.machines,
454
154
			statuses: test.statuses,
455
155
			members:  test.members,
456
156
		}
457
157
		members, voting, err := desiredPeerGroup(info)
458
158
		if test.expectErr != "" {
459
159
			c.Assert(err, gc.ErrorMatches, test.expectErr)
460
160
			c.Assert(members, gc.IsNil)
461
161
			continue
462
162
		}
463
163
		sort.Sort(membersById(members))
464
164
		c.Assert(members, jc.DeepEquals, test.expectMembers)
465
165
		if len(members) == 0 {
466
166
			continue
467
167
		}
468
168
		for i, m := range info.machines {
469
169
			c.Assert(voting[m], gc.Equals, test.expectVoting[i], gc.Commentf("machine %s", m.id))
470
170
		}
471
171
		// Assure ourselves that the total number of desired votes is odd in
472
172
		// all circumstances.
473
173
		c.Assert(countVotes(members)%2, gc.Equals, 1)
474
174
475
175
		// Make sure that when the members are set as
476
176
		// required, that there's no further change
477
177
		// if desiredPeerGroup is called again.
478
178
		info.members = members
479
179
		members, voting, err = desiredPeerGroup(info)
480
180
		c.Assert(members, gc.IsNil)
481
181
		c.Assert(voting, gc.IsNil)
482
182
		c.Assert(err, gc.IsNil)
483
183
	}
484
184
}
485
185
486
186
func countVotes(members []replicaset.Member) int {
487
187
	tot := 0
488
188
	for _, m := range members {
489
189
		v := 1
490
190
		if m.Votes != nil {
491
191
			v = *m.Votes
492
192
		}
493
193
		tot += v
494
194
	}
495
195
	return tot
496
196
}
497
197
498
198
func newInt(i int) *int {
499
199
	return &i
500
200
}
501
201
502
202
func newFloat64(f float64) *float64 {
503
203
	return &f
504
204
}
505
205
506
206
// mkMachines returns a slice of *machine based on
507
207
// the given description.
508
208
// Each machine in the description is white-space separated
509
209
// and holds the decimal machine id followed by an optional
510
210
// "v" if the machine wants a vote.
511
211
func mkMachines(description string) []*machine {
512
212
	descrs := parseDescr(description)
513
213
	ms := make([]*machine, len(descrs))
514
214
	for i, d := range descrs {
515
215
		ms[i] = &machine{
516
216
			id:        fmt.Sprint(d.id),
517
217
			hostPort:  fmt.Sprintf("0.1.2.%d:%d", d.id, mongoPort),
518
218
			wantsVote: strings.Contains(d.flags, "v"),
519
219
		}
520
220
	}
521
221
	return ms
522
222
}
523
223
524
224
func memberTag(id string) map[string]string {
525
225
	return map[string]string{"juju-machine-id": id}
526
226
}
527
227
528
228
// mkMembers returns a slice of *replicaset.Member
529
229
// based on the given description.
530
230
// Each member in the description is white-space separated
531
231
// and holds the decimal replica-set id optionally followed by the characters:
532
232
//	- 'v' if the member is voting.
533
233
// 	- 'T' if the member has no associated machine tags.
534
234
// Unless the T flag is specified, the machine tag
535
235
// will be the replica-set id + 10.
536
236
func mkMembers(description string) []replicaset.Member {
537
237
	descrs := parseDescr(description)
538
238
	ms := make([]replicaset.Member, len(descrs))
539
239
	for i, d := range descrs {
540
240
		machineId := d.id + 10
541
241
		m := replicaset.Member{
542
242
			Id:      d.id,
543
243
			Address: fmt.Sprintf("0.1.2.%d:%d", machineId, mongoPort),
544
244
			Tags:    memberTag(fmt.Sprint(machineId)),
545
245
		}
546
246
		if !strings.Contains(d.flags, "v") {
547
247
			m.Priority = newFloat64(0)
548
248
			m.Votes = newInt(0)
549
249
		}
550
250
		if strings.Contains(d.flags, "T") {
551
251
			m.Tags = nil
552
252
		}
553
253
		ms[i] = m
554
254
	}
555
255
	return ms
556
256
}
557
257
558
258
var stateFlags = map[rune]replicaset.MemberState{
559
259
	'p': replicaset.PrimaryState,
560
260
	's': replicaset.SecondaryState,
561
261
}
562
262
563
263
// mkStatuses returns a slice of *replicaset.Member
564
264
// based on the given description.
565
265
// Each member in the description is white-space separated
566
266
// and holds the decimal replica-set id optionally followed by the
567
267
// characters:
568
268
// 	- 'H' if the instance is not healthy.
569
269
//	- 'p' if the instance is in PrimaryState
570
270
//	- 's' if the instance is in SecondaryState
571
271
func mkStatuses(description string) []replicaset.MemberStatus {
572
272
	descrs := parseDescr(description)
573
273
	ss := make([]replicaset.MemberStatus, len(descrs))
574
274
	for i, d := range descrs {
575
275
		machineId := d.id + 10
576
276
		s := replicaset.MemberStatus{
577
277
			Id:      d.id,
578
278
			Address: fmt.Sprintf("0.1.2.%d:%d", machineId, mongoPort),
579
279
			Healthy: !strings.Contains(d.flags, "H"),
580
280
			State:   replicaset.UnknownState,
581
281
		}
582
282
		for _, r := range d.flags {
583
283
			if state, ok := stateFlags[r]; ok {
584
284
				s.State = state
585
285
			}
586
286
		}
587
287
		ss[i] = s
588
288
	}
589
289
	return ss
590
290
}
591
291
592
292
type descr struct {
593
293
	id    int
594
294
	flags string
595
295
}
596
296
597
297
func isNotDigit(r rune) bool {
598
298
	return r < '0' || r > '9'
599
299
}
600
300
601
301
var parseDescrTests = []struct {
602
302
	descr  string
603
303
	expect []descr
604
304
}{{
605
305
	descr:  "",
606
306
	expect: []descr{},
607
307
}, {
608
308
	descr:  "0",
609
309
	expect: []descr{{id: 0}},
610
310
}, {
611
311
	descr:  "1foo",
612
312
	expect: []descr{{id: 1, flags: "foo"}},
613
313
}, {
614
314
	descr: "10c  5 6443arble ",
615
315
	expect: []descr{{
616
316
		id:    10,
617
317
		flags: "c",
618
318
	}, {
619
319
		id: 5,
620
320
	}, {
621
321
		id:    6443,
622
322
		flags: "arble",
623
323
	}},
624
324
}}
625
325
626
326
func (*desiredPeerGroupSuite) TestParseDescr(c *gc.C) {
627
327
	for i, test := range parseDescrTests {
628
328
		c.Logf("test %d. %q", i, test.descr)
629
329
		c.Assert(parseDescr(test.descr), jc.DeepEquals, test.expect)
630
330
	}
631
331
}
632
332
633
333
// parseDescr parses white-space separated fields of the form
634
334
// <id><flags> into descr structures.
635
335
func parseDescr(s string) []descr {
636
336
	fields := strings.Fields(s)
637
337
	descrs := make([]descr, len(fields))
638
338
	for i, field := range fields {
639
339
		d := &descrs[i]
640
340
		i := strings.IndexFunc(field, isNotDigit)
641
341
		if i == -1 {
642
342
			i = len(field)
643
343
		}
644
344
		id, err := strconv.Atoi(field[0:i])
645
345
		if err != nil {
646
346
			panic(fmt.Errorf("bad field %q", field))
647
347
		}
648
348
		d.id = id
649
349
		d.flags = field[i:]
650
350
	}
651
351
	return descrs
652
352
}
653
353
654
354
type membersById []replicaset.Member
655
355
656
356
func (l membersById) Len() int           { return len(l) }
657
357
func (l membersById) Swap(i, j int)      { l[i], l[j] = l[j], l[i] }
658
358
func (l membersById) Less(i, j int) bool { return l[i].Id < l[j].Id }
Status:	Merged
Approved by:	Roger Peppe on 2014-02-14
Approved revision:	no longer in the source branch.
Merged at revision:	2328
Proposed branch:	lp:~rogpeppe/juju-core/479-desired-peer-group
Merge into:	lp:~go-bot/juju-core/trunk
Diff against target:	658 lines (+648/-0) 2 files modified worker/peergrouper/desired.go (+290/-0) worker/peergrouper/desired_test.go (+358/-0)
To merge this branch:	bzr merge lp:~rogpeppe/juju-core/479-desired-peer-group
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Juju Engineering		2014-01-10	Pending
Review via email: mp+201245@code.launchpad.net