Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(788)

Side by Side Diff: state/apiserver/client/client_test.go

Issue 99670044: Add output for ensure-availability command.
Patch Set: Add output for ensure-availability command. Created 9 years, 10 months ago
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2012, 2013 Canonical Ltd. 1 // Copyright 2012, 2013 Canonical Ltd.
2 // Licensed under the AGPLv3, see LICENCE file for details. 2 // Licensed under the AGPLv3, see LICENCE file for details.
3 3
4 package client_test 4 package client_test
5 5
6 import ( 6 import (
7 "fmt" 7 "fmt"
8 "net/url" 8 "net/url"
9 "strconv" 9 "strconv"
10 "strings" 10 "strings"
(...skipping 2187 matching lines...) Expand 10 before | Expand all | Expand 10 after
2198 _, err := s.State.AddMachine("quantal", state.JobManageEnviron) 2198 _, err := s.State.AddMachine("quantal", state.JobManageEnviron)
2199 c.Assert(err, gc.IsNil) 2199 c.Assert(err, gc.IsNil)
2200 // We have to ensure the agents are alive, or EnsureAvailability will 2200 // We have to ensure the agents are alive, or EnsureAvailability will
2201 // create more to replace them. 2201 // create more to replace them.
2202 pinger := s.setAgentAlive(c, "0") 2202 pinger := s.setAgentAlive(c, "0")
2203 defer pinger.Kill() 2203 defer pinger.Kill()
2204 machines, err := s.State.AllMachines() 2204 machines, err := s.State.AllMachines()
2205 c.Assert(err, gc.IsNil) 2205 c.Assert(err, gc.IsNil)
2206 c.Assert(machines, gc.HasLen, 1) 2206 c.Assert(machines, gc.HasLen, 1)
2207 c.Assert(machines[0].Series(), gc.Equals, "quantal") 2207 c.Assert(machines[0].Series(), gc.Equals, "quantal")
2208 » err = s.APIState.Client().EnsureAvailability(3, emptyCons, defaultSeries ) 2208 » ensureAvailabilityResult, err := s.APIState.Client().EnsureAvailability( 3, emptyCons, defaultSeries)
2209 c.Assert(err, gc.IsNil) 2209 c.Assert(err, gc.IsNil)
2210 c.Assert(ensureAvailabilityResult.Maintained, gc.DeepEquals, []string{"0 "})
2211 c.Assert(ensureAvailabilityResult.Added, gc.DeepEquals, []string{"1", "2 "})
2212 c.Assert(ensureAvailabilityResult.Removed, gc.HasLen, 0)
2213
2210 machines, err = s.State.AllMachines() 2214 machines, err = s.State.AllMachines()
2211 c.Assert(err, gc.IsNil) 2215 c.Assert(err, gc.IsNil)
2212 c.Assert(machines, gc.HasLen, 3) 2216 c.Assert(machines, gc.HasLen, 3)
2213 c.Assert(machines[0].Series(), gc.Equals, "quantal") 2217 c.Assert(machines[0].Series(), gc.Equals, "quantal")
2214 c.Assert(machines[1].Series(), gc.Equals, "quantal") 2218 c.Assert(machines[1].Series(), gc.Equals, "quantal")
2215 c.Assert(machines[2].Series(), gc.Equals, "quantal") 2219 c.Assert(machines[2].Series(), gc.Equals, "quantal")
2216 defer s.setAgentAlive(c, "1").Kill() 2220 defer s.setAgentAlive(c, "1").Kill()
2217 defer s.setAgentAlive(c, "2").Kill() 2221 defer s.setAgentAlive(c, "2").Kill()
2218 » err = s.APIState.Client().EnsureAvailability(5, emptyCons, "non-default" ) 2222 » ensureAvailabilityResult, err = s.APIState.Client().EnsureAvailability(5 , emptyCons, "non-default")
2223 » c.Assert(ensureAvailabilityResult.Maintained, gc.DeepEquals, []string{"0 ", "1", "2"})
2224 » c.Assert(ensureAvailabilityResult.Added, gc.DeepEquals, []string{"3", "4 "})
2225 » c.Assert(ensureAvailabilityResult.Removed, gc.HasLen, 0)
2226
2219 c.Assert(err, gc.IsNil) 2227 c.Assert(err, gc.IsNil)
2220 machines, err = s.State.AllMachines() 2228 machines, err = s.State.AllMachines()
2221 c.Assert(err, gc.IsNil) 2229 c.Assert(err, gc.IsNil)
2222 c.Assert(machines, gc.HasLen, 5) 2230 c.Assert(machines, gc.HasLen, 5)
2223 c.Assert(machines[0].Series(), gc.Equals, "quantal") 2231 c.Assert(machines[0].Series(), gc.Equals, "quantal")
2224 c.Assert(machines[1].Series(), gc.Equals, "quantal") 2232 c.Assert(machines[1].Series(), gc.Equals, "quantal")
2225 c.Assert(machines[2].Series(), gc.Equals, "quantal") 2233 c.Assert(machines[2].Series(), gc.Equals, "quantal")
2226 c.Assert(machines[3].Series(), gc.Equals, "non-default") 2234 c.Assert(machines[3].Series(), gc.Equals, "non-default")
2227 c.Assert(machines[4].Series(), gc.Equals, "non-default") 2235 c.Assert(machines[4].Series(), gc.Equals, "non-default")
2228 } 2236 }
2229 2237
2230 func (s *clientSuite) TestClientEnsureAvailabilityConstraints(c *gc.C) { 2238 func (s *clientSuite) TestClientEnsureAvailabilityConstraints(c *gc.C) {
2231 _, err := s.State.AddMachine("quantal", state.JobManageEnviron) 2239 _, err := s.State.AddMachine("quantal", state.JobManageEnviron)
2232 c.Assert(err, gc.IsNil) 2240 c.Assert(err, gc.IsNil)
2233 pinger := s.setAgentAlive(c, "0") 2241 pinger := s.setAgentAlive(c, "0")
2234 defer pinger.Kill() 2242 defer pinger.Kill()
2235 » err = s.APIState.Client().EnsureAvailability( 2243 » ensureAvailabilityResult, err := s.APIState.Client().EnsureAvailability(
2236 3, constraints.MustParse("mem=4G"), defaultSeries) 2244 3, constraints.MustParse("mem=4G"), defaultSeries)
2237 c.Assert(err, gc.IsNil) 2245 c.Assert(err, gc.IsNil)
2246 c.Assert(ensureAvailabilityResult.Maintained, gc.DeepEquals, []string{"0 "})
2247 c.Assert(ensureAvailabilityResult.Added, gc.DeepEquals, []string{"1", "2 "})
2248 c.Assert(ensureAvailabilityResult.Removed, gc.HasLen, 0)
2249
2238 machines, err := s.State.AllMachines() 2250 machines, err := s.State.AllMachines()
2239 c.Assert(err, gc.IsNil) 2251 c.Assert(err, gc.IsNil)
2240 c.Assert(machines, gc.HasLen, 3) 2252 c.Assert(machines, gc.HasLen, 3)
2241 expectedCons := []constraints.Value{ 2253 expectedCons := []constraints.Value{
2242 constraints.Value{}, 2254 constraints.Value{},
2243 constraints.MustParse("mem=4G"), 2255 constraints.MustParse("mem=4G"),
2244 constraints.MustParse("mem=4G"), 2256 constraints.MustParse("mem=4G"),
2245 } 2257 }
2246 for i, m := range machines { 2258 for i, m := range machines {
2247 cons, err := m.Constraints() 2259 cons, err := m.Constraints()
2248 c.Assert(err, gc.IsNil) 2260 c.Assert(err, gc.IsNil)
2249 c.Check(cons, gc.DeepEquals, expectedCons[i]) 2261 c.Check(cons, gc.DeepEquals, expectedCons[i])
2250 } 2262 }
2251 } 2263 }
2252 2264
2253 func (s *clientSuite) TestClientEnsureAvailability0Preserves(c *gc.C) { 2265 func (s *clientSuite) TestClientEnsureAvailability0Preserves(c *gc.C) {
2254 _, err := s.State.AddMachine("quantal", state.JobManageEnviron) 2266 _, err := s.State.AddMachine("quantal", state.JobManageEnviron)
2255 c.Assert(err, gc.IsNil) 2267 c.Assert(err, gc.IsNil)
2256 pinger := s.setAgentAlive(c, "0") 2268 pinger := s.setAgentAlive(c, "0")
2257 defer pinger.Kill() 2269 defer pinger.Kill()
2258 // A value of 0 says either "if I'm not HA, make me HA" or "preserve my 2270 // A value of 0 says either "if I'm not HA, make me HA" or "preserve my
2259 // current HA settings". 2271 // current HA settings".
2260 » err = s.APIState.Client().EnsureAvailability(0, emptyCons, defaultSeries ) 2272 » ensureAvailabilityResult, err := s.APIState.Client().EnsureAvailability( 0, emptyCons, defaultSeries)
2261 c.Assert(err, gc.IsNil) 2273 c.Assert(err, gc.IsNil)
2274 c.Assert(ensureAvailabilityResult.Maintained, gc.DeepEquals, []string{"0 "})
2275 c.Assert(ensureAvailabilityResult.Added, gc.DeepEquals, []string{"1", "2 "})
2276 c.Assert(ensureAvailabilityResult.Removed, gc.HasLen, 0)
2277
2262 machines, err := s.State.AllMachines() 2278 machines, err := s.State.AllMachines()
2263 c.Assert(machines, gc.HasLen, 3) 2279 c.Assert(machines, gc.HasLen, 3)
2264 defer s.setAgentAlive(c, "1").Kill() 2280 defer s.setAgentAlive(c, "1").Kill()
2265 // Now, we keep agent 1 alive, but not agent 2, calling 2281 // Now, we keep agent 1 alive, but not agent 2, calling
2266 // EnsureAvailability(0) again will cause us to start another machine 2282 // EnsureAvailability(0) again will cause us to start another machine
2267 » err = s.APIState.Client().EnsureAvailability(0, emptyCons, defaultSeries ) 2283 » ensureAvailabilityResult, err = s.APIState.Client().EnsureAvailability(0 , emptyCons, defaultSeries)
2268 c.Assert(err, gc.IsNil) 2284 c.Assert(err, gc.IsNil)
2285 c.Assert(ensureAvailabilityResult.Maintained, gc.DeepEquals, []string{"0 ", "1", "2"})
2286 c.Assert(ensureAvailabilityResult.Added, gc.DeepEquals, []string{"3"})
2287 c.Assert(ensureAvailabilityResult.Removed, gc.HasLen, 0)
2288
2269 machines, err = s.State.AllMachines() 2289 machines, err = s.State.AllMachines()
2270 c.Assert(machines, gc.HasLen, 4) 2290 c.Assert(machines, gc.HasLen, 4)
2271 } 2291 }
2272 2292
2273 func (s *clientSuite) TestClientEnsureAvailability0Preserves5(c *gc.C) { 2293 func (s *clientSuite) TestClientEnsureAvailability0Preserves5(c *gc.C) {
2274 _, err := s.State.AddMachine("quantal", state.JobManageEnviron) 2294 _, err := s.State.AddMachine("quantal", state.JobManageEnviron)
2275 c.Assert(err, gc.IsNil) 2295 c.Assert(err, gc.IsNil)
2276 pinger := s.setAgentAlive(c, "0") 2296 pinger := s.setAgentAlive(c, "0")
2277 defer pinger.Kill() 2297 defer pinger.Kill()
2278 // Start off with 5 servers 2298 // Start off with 5 servers
2279 » err = s.APIState.Client().EnsureAvailability(5, emptyCons, defaultSeries ) 2299 » ensureAvailabilityResult, err := s.APIState.Client().EnsureAvailability( 5, emptyCons, defaultSeries)
2280 c.Assert(err, gc.IsNil) 2300 c.Assert(err, gc.IsNil)
2301 c.Assert(ensureAvailabilityResult.Maintained, gc.DeepEquals, []string{"0 "})
2302 c.Assert(ensureAvailabilityResult.Added, gc.DeepEquals, []string{"1", "2 ", "3", "4"})
2303 c.Assert(ensureAvailabilityResult.Removed, gc.HasLen, 0)
2304
2281 machines, err := s.State.AllMachines() 2305 machines, err := s.State.AllMachines()
2282 c.Assert(machines, gc.HasLen, 5) 2306 c.Assert(machines, gc.HasLen, 5)
2283 defer s.setAgentAlive(c, "1").Kill() 2307 defer s.setAgentAlive(c, "1").Kill()
2284 defer s.setAgentAlive(c, "2").Kill() 2308 defer s.setAgentAlive(c, "2").Kill()
2285 defer s.setAgentAlive(c, "3").Kill() 2309 defer s.setAgentAlive(c, "3").Kill()
2286 // Keeping all alive but one, will bring up 1 more server to preserve 5 2310 // Keeping all alive but one, will bring up 1 more server to preserve 5
2287 » err = s.APIState.Client().EnsureAvailability(0, emptyCons, defaultSeries ) 2311 » ensureAvailabilityResult, err = s.APIState.Client().EnsureAvailability(0 , emptyCons, defaultSeries)
2312 » c.Assert(ensureAvailabilityResult.Maintained, gc.DeepEquals, []string{"0 ", "1", "2", "3", "4"})
2313 » c.Assert(ensureAvailabilityResult.Added, gc.DeepEquals, []string{"5"})
2314 » c.Assert(ensureAvailabilityResult.Removed, gc.HasLen, 0)
2315
2288 c.Assert(err, gc.IsNil) 2316 c.Assert(err, gc.IsNil)
2289 machines, err = s.State.AllMachines() 2317 machines, err = s.State.AllMachines()
2290 c.Assert(machines, gc.HasLen, 6) 2318 c.Assert(machines, gc.HasLen, 6)
2291 } 2319 }
2292 2320
2293 func (s *clientSuite) TestClientEnsureAvailabilityErrors(c *gc.C) { 2321 func (s *clientSuite) TestClientEnsureAvailabilityErrors(c *gc.C) {
2294 _, err := s.State.AddMachine("quantal", state.JobManageEnviron) 2322 _, err := s.State.AddMachine("quantal", state.JobManageEnviron)
2295 c.Assert(err, gc.IsNil) 2323 c.Assert(err, gc.IsNil)
2296 pinger := s.setAgentAlive(c, "0") 2324 pinger := s.setAgentAlive(c, "0")
2297 defer pinger.Kill() 2325 defer pinger.Kill()
2298 » err = s.APIState.Client().EnsureAvailability(-1, emptyCons, defaultSerie s) 2326 » _, err = s.APIState.Client().EnsureAvailability(-1, emptyCons, defaultSe ries)
2299 c.Assert(err, gc.ErrorMatches, "number of state servers must be odd and non-negative") 2327 c.Assert(err, gc.ErrorMatches, "number of state servers must be odd and non-negative")
2300 » err = s.APIState.Client().EnsureAvailability(3, emptyCons, defaultSeries ) 2328 » ensureAvailabilityResult, err := s.APIState.Client().EnsureAvailability( 3, emptyCons, defaultSeries)
2301 c.Assert(err, gc.IsNil) 2329 c.Assert(err, gc.IsNil)
2302 » err = s.APIState.Client().EnsureAvailability(1, emptyCons, defaultSeries ) 2330 » c.Assert(ensureAvailabilityResult.Maintained, gc.DeepEquals, []string{"0 "})
2331 » c.Assert(ensureAvailabilityResult.Added, gc.DeepEquals, []string{"1", "2 "})
2332 » c.Assert(ensureAvailabilityResult.Removed, gc.HasLen, 0)
2333
2334 » _, err = s.APIState.Client().EnsureAvailability(1, emptyCons, defaultSer ies)
2303 c.Assert(err, gc.ErrorMatches, "cannot reduce state server count") 2335 c.Assert(err, gc.ErrorMatches, "cannot reduce state server count")
2304 } 2336 }
2305 2337
2306 func (s *clientSuite) TestAPIHostPorts(c *gc.C) { 2338 func (s *clientSuite) TestAPIHostPorts(c *gc.C) {
2307 apiHostPorts, err := s.APIState.Client().APIHostPorts() 2339 apiHostPorts, err := s.APIState.Client().APIHostPorts()
2308 c.Assert(err, gc.IsNil) 2340 c.Assert(err, gc.IsNil)
2309 c.Assert(apiHostPorts, gc.HasLen, 0) 2341 c.Assert(apiHostPorts, gc.HasLen, 0)
2310 2342
2311 server1Addresses := []instance.Address{{ 2343 server1Addresses := []instance.Address{{
2312 Value: "server-1", 2344 Value: "server-1",
(...skipping 23 matching lines...) Expand all
2336 c.Assert(apiHostPorts, gc.DeepEquals, stateAPIHostPorts) 2368 c.Assert(apiHostPorts, gc.DeepEquals, stateAPIHostPorts)
2337 } 2369 }
2338 2370
2339 func (s *clientSuite) TestClientAgentVersion(c *gc.C) { 2371 func (s *clientSuite) TestClientAgentVersion(c *gc.C) {
2340 current := version.MustParse("1.2.0") 2372 current := version.MustParse("1.2.0")
2341 s.PatchValue(&version.Current.Number, current) 2373 s.PatchValue(&version.Current.Number, current)
2342 result, err := s.APIState.Client().AgentVersion() 2374 result, err := s.APIState.Client().AgentVersion()
2343 c.Assert(err, gc.IsNil) 2375 c.Assert(err, gc.IsNil)
2344 c.Assert(result, gc.Equals, current) 2376 c.Assert(result, gc.Equals, current)
2345 } 2377 }
2378
2379 func (s *clientSuite) TestEnsureAvailabilityResultFromSSI(c *gc.C) {
2380 type ensureAvailabilityResultTest struct {
2381 about string
2382 ssiBefore []string
2383 ssiAfter []string
2384 added []string
2385 removed []string
2386 maintained []string
2387 }
2388
2389 var ensureAvailabilityResultTests = []ensureAvailabilityResultTest{
2390 ensureAvailabilityResultTest{
2391 about: "no change",
2392 ssiBefore: []string{"0", "1", "2"},
2393 ssiAfter: []string{"0", "1", "2"},
2394 added: []string{},
2395 removed: []string{},
2396 maintained: []string{"0", "1", "2"},
2397 },
2398 ensureAvailabilityResultTest{
2399 about: "added",
2400 ssiBefore: []string{"0"},
2401 ssiAfter: []string{"0", "1", "2"},
2402 added: []string{"1", "2"},
2403 removed: []string{},
2404 maintained: []string{"0"},
2405 },
2406 ensureAvailabilityResultTest{
2407 about: "removed",
2408 ssiBefore: []string{"0", "1", "2"},
2409 ssiAfter: []string{"1"},
2410 added: []string{},
2411 removed: []string{"0", "2"},
2412 maintained: []string{"1"},
2413 },
2414 ensureAvailabilityResultTest{
2415 about: "added and removed",
2416 ssiBefore: []string{"0", "1", "2"},
2417 ssiAfter: []string{"0", "2", "3", "4"},
2418 added: []string{"3", "4"},
2419 removed: []string{"1"},
2420 maintained: []string{"0", "2"},
2421 },
2422 ensureAvailabilityResultTest{
2423 about: "added at end",
2424 ssiBefore: []string{"0", "1", "2"},
2425 ssiAfter: []string{"0", "1", "2", "3", "4"},
2426 added: []string{"3", "4"},
2427 removed: []string{},
2428 maintained: []string{"0", "1", "2"},
2429 },
2430 ensureAvailabilityResultTest{
2431 about: "removed at end",
2432 ssiBefore: []string{"0", "1", "2", "3", "4"},
2433 ssiAfter: []string{"0", "1", "2"},
2434 added: []string{},
2435 removed: []string{"3", "4"},
2436 maintained: []string{"0", "1", "2"},
2437 },
2438 }
2439
2440 for i, tst := range ensureAvailabilityResultTests {
2441 c.Logf("test %d. %s", i, tst.about)
2442
2443 before := state.StateServerInfo{
2444 MachineIds: tst.ssiBefore,
2445 }
2446 after := state.StateServerInfo{
2447 MachineIds: tst.ssiAfter,
2448 }
2449 result := client.EnsureAvailabilityResultFromSSI(&before, &after )
2450 c.Assert(result.Added, gc.DeepEquals, tst.added)
2451 c.Assert(result.Removed, gc.DeepEquals, tst.removed)
2452 c.Assert(result.Maintained, gc.DeepEquals, tst.maintained)
2453 }
2454 }
OLDNEW

Powered by Google App Engine
RSS Feeds Recent Issues | This issue
This is Rietveld f62528b