1
=== modified file 'juju/api.go'
2
--- juju/api.go	2014-03-19 03:18:41 +0000
3
+++ juju/api.go	2014-03-31 12:32:07 +0000
4
@@ -14,6 +14,7 @@
5
14
	"launchpad.net/juju-core/environs/config"
14
	"launchpad.net/juju-core/environs/config"
6
15
	"launchpad.net/juju-core/environs/configstore"
15
	"launchpad.net/juju-core/environs/configstore"
7
16
	"launchpad.net/juju-core/errors"
16
	"launchpad.net/juju-core/errors"
8
17
	"launchpad.net/juju-core/instance"
9
17
	"launchpad.net/juju-core/juju/osenv"
18
	"launchpad.net/juju-core/juju/osenv"
10
18
	"launchpad.net/juju-core/names"
19
	"launchpad.net/juju-core/names"
11
19
	"launchpad.net/juju-core/state/api"
20
	"launchpad.net/juju-core/state/api"
12
@@ -26,24 +27,25 @@
13
26
// The following are variables so that they can be
27
// The following are variables so that they can be
14
27
// changed by tests.
28
// changed by tests.
15
28
var (
29
var (
16
29
	apiOpen              = api.Open
17
30
	apiClose             = (*api.State).Close
18
31
	providerConnectDelay = 2 * time.Second
30
	providerConnectDelay = 2 * time.Second
19
32
)
31
)
20
33
32
25
34
// apiState wraps an api.State, redefining its Close method
33
// apiState provides a subset of api.State's public
26
35
// so we can abuse it for testing purposes.
34
// interface, defined here so it can be mocked.
27
36
type apiState struct {
35
type apiState interface {
28
37
	st *api.State
36
	Close() error
29
37
	APIHostPorts() [][]instance.HostPort
30
38
}
31
39
32
40
type apiOpenFunc func(*api.Info, api.DialOpts) (apiState, error)
33
41
34
42
type apiStateCachedInfo struct {
35
43
	apiState
36
38
	// If cachedInfo is non-nil, it indicates that the info has been
44
	// If cachedInfo is non-nil, it indicates that the info has been
37
39
	// newly retrieved, and should be cached in the config store.
45
	// newly retrieved, and should be cached in the config store.
38
40
	cachedInfo *api.Info
46
	cachedInfo *api.Info
39
41
}
47
}
40
42
48
41
43
func (st apiState) Close() error {
42
44
	return apiClose(st.st)
43
45
}
44
46
45
47
// APIConn holds a connection to a juju environment and its
49
// APIConn holds a connection to a juju environment and its
46
48
// associated state through its API interface.
50
// associated state through its API interface.
47
49
type APIConn struct {
51
type APIConn struct {
48
@@ -62,7 +64,7 @@
49
62
		return nil, err
64
		return nil, err
50
63
	}
65
	}
51
64
66
53
65
	st, err := apiOpen(info, dialOpts)
67
	st, err := api.Open(info, dialOpts)
54
66
	// TODO(rog): handle errUnauthorized when the API handles passwords.
68
	// TODO(rog): handle errUnauthorized when the API handles passwords.
55
67
	if err != nil {
69
	if err != nil {
56
68
		return nil, err
70
		return nil, err
57
@@ -76,7 +78,7 @@
58
76
// Close terminates the connection to the environment and releases
78
// Close terminates the connection to the environment and releases
59
77
// any associated resources.
79
// any associated resources.
60
78
func (c *APIConn) Close() error {
80
func (c *APIConn) Close() error {
62
79
	return apiClose(c.State)
81
	return c.State.Close()
63
80
}
82
}
64
81
83
65
82
// NewAPIClientFromName returns an api.Client connected to the API Server for
84
// NewAPIClientFromName returns an api.Client connected to the API Server for
66
@@ -112,12 +114,19 @@
67
112
	if err != nil {
114
	if err != nil {
68
113
		return nil, err
115
		return nil, err
69
114
	}
116
	}
71
115
	return newAPIFromStore(envName, store)
117
	apiOpen := func(info *api.Info, opts api.DialOpts) (apiState, error) {
72
118
		return api.Open(info, opts)
73
119
	}
74
120
	st, err := newAPIFromStore(envName, store, apiOpen)
75
121
	if err != nil {
76
122
		return nil, err
77
123
	}
78
124
	return st.(*api.State), nil
79
116
}
125
}
80
117
126
81
118
// newAPIFromStore implements the bulk of NewAPIClientFromName
127
// newAPIFromStore implements the bulk of NewAPIClientFromName
82
119
// but is separate for testing purposes.
128
// but is separate for testing purposes.
84
120
func newAPIFromStore(envName string, store configstore.Storage) (*api.State, error) {
129
func newAPIFromStore(envName string, store configstore.Storage, apiOpen apiOpenFunc) (apiState, error) {
85
121
	// Try to read the default environment configuration file.
130
	// Try to read the default environment configuration file.
86
122
	// If it doesn't exist, we carry on in case
131
	// If it doesn't exist, we carry on in case
87
123
	// there's some environment info for that environment.
132
	// there's some environment info for that environment.
88
@@ -170,7 +179,7 @@
89
170
	if info != nil && len(info.APIEndpoint().Addresses) > 0 {
179
	if info != nil && len(info.APIEndpoint().Addresses) > 0 {
90
171
		logger.Debugf("trying cached API connection settings")
180
		logger.Debugf("trying cached API connection settings")
91
172
		try.Start(func(stop <-chan struct{}) (io.Closer, error) {
181
		try.Start(func(stop <-chan struct{}) (io.Closer, error) {
93
173
			return apiInfoConnect(store, info, stop)
182
			return apiInfoConnect(store, info, apiOpen, stop)
94
174
		})
183
		})
95
175
		// Delay the config connection until we've spent
184
		// Delay the config connection until we've spent
96
176
		// some time trying to connect to the cached info.
185
		// some time trying to connect to the cached info.
97
@@ -179,7 +188,7 @@
98
179
		logger.Debugf("no cached API connection settings found")
188
		logger.Debugf("no cached API connection settings found")
99
180
	}
189
	}
100
181
	try.Start(func(stop <-chan struct{}) (io.Closer, error) {
190
	try.Start(func(stop <-chan struct{}) (io.Closer, error) {
102
182
		return apiConfigConnect(info, envs, envName, stop, delay)
191
		return apiConfigConnect(info, envs, envName, apiOpen, stop, delay)
103
183
	})
192
	})
104
184
	try.Close()
193
	try.Close()
105
185
	val0, err := try.Result()
194
	val0, err := try.Result()
106
@@ -190,20 +199,23 @@
107
190
		}
199
		}
108
191
		return nil, err
200
		return nil, err
109
192
	}
201
	}
110
202
111
193
	val := val0.(apiState)
203
	val := val0.(apiState)
122
194
204
	if cachedInfo, ok := val.(apiStateCachedInfo); ok {
123
195
	if val.cachedInfo != nil && info != nil {
205
		val = cachedInfo.apiState
124
196
		// Cache the connection settings only if we used the
206
		if cachedInfo.cachedInfo != nil && info != nil {
125
197
		// environment config, but any errors are just logged
207
			// Cache the connection settings only if we used the
126
198
		// as warnings, because they're not fatal.
208
			// environment config, but any errors are just logged
127
199
		err = cacheAPIInfo(info, val.cachedInfo)
209
			// as warnings, because they're not fatal.
128
200
		if err != nil {
210
			err = cacheAPIInfo(info, cachedInfo.cachedInfo)
129
201
			logger.Warningf(err.Error())
211
			if err != nil {
130
202
		} else {
212
				logger.Warningf("cannot cache API connection settings: %v", err.Error())
131
203
			logger.Debugf("updated API connection settings cache")
213
			} else {
132
214
				logger.Infof("updated API connection settings cache")
133
215
			}
134
204
		}
216
		}
135
205
	}
217
	}
137
206
	return val.st, nil
218
	return val, nil
138
207
}
219
}
139
208
220
140
209
func errorImportance(err error) int {
221
func errorImportance(err error) int {
141
@@ -230,10 +242,10 @@
142
230
242
143
231
// apiInfoConnect looks for endpoint on the given environment and
243
// apiInfoConnect looks for endpoint on the given environment and
144
232
// tries to connect to it, sending the result on the returned channel.
244
// tries to connect to it, sending the result on the returned channel.
146
233
func apiInfoConnect(store configstore.Storage, info configstore.EnvironInfo, stop <-chan struct{}) (apiState, error) {
245
func apiInfoConnect(store configstore.Storage, info configstore.EnvironInfo, apiOpen apiOpenFunc, stop <-chan struct{}) (apiState, error) {
147
234
	endpoint := info.APIEndpoint()
246
	endpoint := info.APIEndpoint()
148
235
	if info == nil || len(endpoint.Addresses) == 0 {
247
	if info == nil || len(endpoint.Addresses) == 0 {
150
236
		return apiState{}, &infoConnectError{fmt.Errorf("no cached addresses")}
248
		return nil, &infoConnectError{fmt.Errorf("no cached addresses")}
151
237
	}
249
	}
152
238
	logger.Infof("connecting to API addresses: %v", endpoint.Addresses)
250
	logger.Infof("connecting to API addresses: %v", endpoint.Addresses)
153
239
	apiInfo := &api.Info{
251
	apiInfo := &api.Info{
154
@@ -244,9 +256,19 @@
155
244
	}
256
	}
156
245
	st, err := apiOpen(apiInfo, api.DefaultDialOpts())
257
	st, err := apiOpen(apiInfo, api.DefaultDialOpts())
157
246
	if err != nil {
258
	if err != nil {
161
247
		return apiState{}, &infoConnectError{err}
259
		return nil, &infoConnectError{err}
162
248
	}
260
	}
163
249
	return apiState{st, nil}, err
261
	var addrs []string
164
262
	for _, serverHostPorts := range st.APIHostPorts() {
165
263
		for _, hostPort := range serverHostPorts {
166
264
			addrs = append(addrs, hostPort.NetAddr())
167
265
		}
168
266
	}
169
267
	// Update API addresses if they've changed. Error is non-fatal.
170
268
	if err := cacheChangedAPIAddresses(info, addrs); err != nil {
171
269
		logger.Warningf("cannot cache API addresses: %v", err.Error())
172
270
	}
173
271
	return st, err
174
250
}
272
}
175
251
273
176
252
// apiConfigConnect looks for configuration info on the given environment,
274
// apiConfigConnect looks for configuration info on the given environment,
177
@@ -254,7 +276,7 @@
178
254
// its endpoint. It only starts the attempt after the given delay,
276
// its endpoint. It only starts the attempt after the given delay,
179
255
// to allow the faster apiInfoConnect to hopefully succeed first.
277
// to allow the faster apiInfoConnect to hopefully succeed first.
180
256
// It returns nil if there was no configuration information found.
278
// It returns nil if there was no configuration information found.
182
257
func apiConfigConnect(info configstore.EnvironInfo, envs *environs.Environs, envName string, stop <-chan struct{}, delay time.Duration) (apiState, error) {
279
func apiConfigConnect(info configstore.EnvironInfo, envs *environs.Environs, envName string, apiOpen apiOpenFunc, stop <-chan struct{}, delay time.Duration) (apiState, error) {
183
258
	var cfg *config.Config
280
	var cfg *config.Config
184
259
	var err error
281
	var err error
185
260
	if info != nil && len(info.BootstrapConfig()) > 0 {
282
	if info != nil && len(info.BootstrapConfig()) > 0 {
186
@@ -262,30 +284,30 @@
187
262
	} else if envs != nil {
284
	} else if envs != nil {
188
263
		cfg, err = envs.Config(envName)
285
		cfg, err = envs.Config(envName)
189
264
		if errors.IsNotFoundError(err) {
286
		if errors.IsNotFoundError(err) {
191
265
			return apiState{}, err
287
			return nil, err
192
266
		}
288
		}
193
267
	} else {
289
	} else {
195
268
		return apiState{}, errors.NotFoundf("environment %q", envName)
290
		return nil, errors.NotFoundf("environment %q", envName)
196
269
	}
291
	}
197
270
	select {
292
	select {
198
271
	case <-time.After(delay):
293
	case <-time.After(delay):
199
272
	case <-stop:
294
	case <-stop:
201
273
		return apiState{}, errAborted
295
		return nil, errAborted
202
274
	}
296
	}
203
275
	environ, err := environs.New(cfg)
297
	environ, err := environs.New(cfg)
204
276
	if err != nil {
298
	if err != nil {
206
277
		return apiState{}, err
299
		return nil, err
207
278
	}
300
	}
208
279
	apiInfo, err := environAPIInfo(environ)
301
	apiInfo, err := environAPIInfo(environ)
209
280
	if err != nil {
302
	if err != nil {
211
281
		return apiState{}, err
303
		return nil, err
212
282
	}
304
	}
213
283
	st, err := apiOpen(apiInfo, api.DefaultDialOpts())
305
	st, err := apiOpen(apiInfo, api.DefaultDialOpts())
214
284
	// TODO(rog): handle errUnauthorized when the API handles passwords.
306
	// TODO(rog): handle errUnauthorized when the API handles passwords.
215
285
	if err != nil {
307
	if err != nil {
217
286
		return apiState{}, err
308
		return nil, err
218
287
	}
309
	}
220
288
	return apiState{st, apiInfo}, nil
310
	return apiStateCachedInfo{st, apiInfo}, nil
221
289
}
311
}
222
290
312
223
291
func environAPIInfo(environ environs.Environ) (*api.Info, error) {
313
func environAPIInfo(environ environs.Environ) (*api.Info, error) {
224
@@ -312,14 +334,42 @@
225
312
	})
334
	})
226
313
	_, username, err := names.ParseTag(apiInfo.Tag, names.UserTagKind)
335
	_, username, err := names.ParseTag(apiInfo.Tag, names.UserTagKind)
227
314
	if err != nil {
336
	if err != nil {
229
315
		return fmt.Errorf("not caching API connection settings: invalid API user tag: %v", err)
337
		return fmt.Errorf("invalid API user tag: %v", err)
230
316
	}
338
	}
231
317
	info.SetAPICredentials(configstore.APICredentials{
339
	info.SetAPICredentials(configstore.APICredentials{
232
318
		User:     username,
340
		User:     username,
233
319
		Password: apiInfo.Password,
341
		Password: apiInfo.Password,
234
320
	})
342
	})
235
343
	return info.Write()
236
344
}
237
345
238
346
// cacheChangedAPIAddresses updates the local environment settings (.jenv file)
239
347
// with the provided API server addresses if they have changed.
240
348
func cacheChangedAPIAddresses(info configstore.EnvironInfo, addrs []string) error {
241
349
	endpoint := info.APIEndpoint()
242
350
	if !addrsChanged(endpoint.Addresses, addrs) {
243
351
		return nil
244
352
	}
245
353
	logger.Debugf("API addresses changed from %q to %q", endpoint.Addresses, addrs)
246
354
	endpoint.Addresses = addrs
247
355
	info.SetAPIEndpoint(endpoint)
248
321
	if err := info.Write(); err != nil {
356
	if err := info.Write(); err != nil {
250
322
		return fmt.Errorf("cannot cache API connection settings: %v", err)
357
		return err
251
323
	}
358
	}
252
359
	logger.Infof("updated API connection settings cache")
253
324
	return nil
360
	return nil
254
325
}
361
}
255
362
256
363
// addrsChanged returns true iff the two
257
364
// slices are not equal. Order is important.
258
365
func addrsChanged(a, b []string) bool {
259
366
	if len(a) != len(b) {
260
367
		return true
261
368
	}
262
369
	for i := range a {
263
370
		if a[i] != b[i] {
264
371
			return true
265
372
		}
266
373
	}
267
374
	return false
268
375
}
269
326
376
270
=== modified file 'juju/apiconn_test.go'
271
--- juju/apiconn_test.go	2014-03-19 22:16:15 +0000
272
+++ juju/apiconn_test.go	2014-03-31 12:32:07 +0000
273
@@ -8,7 +8,6 @@
274
8
	"os"
8
	"os"
275
9
	"time"
9
	"time"
276
10
10
277
11
	"github.com/juju/testing"
278
12
	jc "github.com/juju/testing/checkers"
11
	jc "github.com/juju/testing/checkers"
279
13
	gc "launchpad.net/gocheck"
12
	gc "launchpad.net/gocheck"
280
14
13
281
@@ -18,6 +17,7 @@
282
18
	"launchpad.net/juju-core/environs/config"
17
	"launchpad.net/juju-core/environs/config"
283
19
	"launchpad.net/juju-core/environs/configstore"
18
	"launchpad.net/juju-core/environs/configstore"
284
20
	envtesting "launchpad.net/juju-core/environs/testing"
19
	envtesting "launchpad.net/juju-core/environs/testing"
285
20
	"launchpad.net/juju-core/instance"
286
21
	"launchpad.net/juju-core/juju"
21
	"launchpad.net/juju-core/juju"
287
22
	"launchpad.net/juju-core/juju/osenv"
22
	"launchpad.net/juju-core/juju/osenv"
288
23
	"launchpad.net/juju-core/provider/dummy"
23
	"launchpad.net/juju-core/provider/dummy"
289
@@ -131,8 +131,12 @@
290
131
	store := newConfigStore("noconfig", storeConfig)
131
	store := newConfigStore("noconfig", storeConfig)
291
132
132
292
133
	called := 0
133
	called := 0
295
134
	expectState := new(api.State)
134
	expectState := &mockAPIState{
296
135
	apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (*api.State, error) {
135
		apiHostPorts: [][]instance.HostPort{
297
136
			instance.AddressesWithPort([]instance.Address{instance.NewAddress("0.1.2.3")}, 1234),
298
137
		},
299
138
	}
300
139
	apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
301
136
		c.Check(apiInfo.Tag, gc.Equals, "user-foo")
140
		c.Check(apiInfo.Tag, gc.Equals, "user-foo")
302
137
		c.Check(string(apiInfo.CACert), gc.Equals, "certificated")
141
		c.Check(string(apiInfo.CACert), gc.Equals, "certificated")
303
138
		c.Check(apiInfo.Password, gc.Equals, "foopass")
142
		c.Check(apiInfo.Password, gc.Equals, "foopass")
304
@@ -140,14 +144,25 @@
305
140
		called++
144
		called++
306
141
		return expectState, nil
145
		return expectState, nil
307
142
	}
146
	}
308
147
309
143
	// Give NewAPIFromStore a store interface that can report when the
148
	// Give NewAPIFromStore a store interface that can report when the
312
144
	// config was written to, to ensure the cache isn't updated.
149
	// config was written to, to check if the cache is updated.
311
145
	s.PatchValue(juju.APIOpen, apiOpen)
313
146
	mockStore := &storageWithWriteNotify{store: store}
150
	mockStore := &storageWithWriteNotify{store: store}
315
147
	st, err := juju.NewAPIFromStore("noconfig", mockStore)
151
	st, err := juju.NewAPIFromStore("noconfig", mockStore, apiOpen)
316
148
	c.Assert(err, gc.IsNil)
152
	c.Assert(err, gc.IsNil)
317
149
	c.Assert(st, gc.Equals, expectState)
153
	c.Assert(st, gc.Equals, expectState)
318
150
	c.Assert(called, gc.Equals, 1)
154
	c.Assert(called, gc.Equals, 1)
319
155
	c.Assert(mockStore.written, jc.IsTrue)
320
156
	info, err := store.ReadInfo("noconfig")
321
157
	c.Assert(err, gc.IsNil)
322
158
	c.Assert(info.APIEndpoint().Addresses, gc.DeepEquals, []string{"0.1.2.3:1234"})
323
159
	mockStore.written = false
324
160
325
161
	// If APIHostPorts haven't changed, then the store won't be updated.
326
162
	st, err = juju.NewAPIFromStore("noconfig", mockStore, apiOpen)
327
163
	c.Assert(err, gc.IsNil)
328
164
	c.Assert(st, gc.Equals, expectState)
329
165
	c.Assert(called, gc.Equals, 2)
330
151
	c.Assert(mockStore.written, jc.IsFalse)
166
	c.Assert(mockStore.written, jc.IsFalse)
331
152
}
167
}
332
153
168
333
@@ -177,8 +192,8 @@
334
177
	c.Assert(info.APICredentials(), jc.DeepEquals, configstore.APICredentials{})
192
	c.Assert(info.APICredentials(), jc.DeepEquals, configstore.APICredentials{})
335
178
193
336
179
	called := 0
194
	called := 0
339
180
	expectState := new(api.State)
195
	expectState := &mockAPIState{}
340
181
	apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (*api.State, error) {
196
	apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
341
182
		c.Check(apiInfo.Tag, gc.Equals, "user-admin")
197
		c.Check(apiInfo.Tag, gc.Equals, "user-admin")
342
183
		c.Check(string(apiInfo.CACert), gc.Not(gc.Equals), "")
198
		c.Check(string(apiInfo.CACert), gc.Not(gc.Equals), "")
343
184
		c.Check(apiInfo.Password, gc.Equals, "adminpass")
199
		c.Check(apiInfo.Password, gc.Equals, "adminpass")
344
@@ -186,8 +201,7 @@
345
186
		called++
201
		called++
346
187
		return expectState, nil
202
		return expectState, nil
347
188
	}
203
	}
350
189
	s.PatchValue(juju.APIOpen, apiOpen)
204
	st, err := juju.NewAPIFromStore("myenv", store, apiOpen)
349
190
	st, err := juju.NewAPIFromStore("myenv", store)
351
191
	c.Assert(err, gc.IsNil)
205
	c.Assert(err, gc.IsNil)
352
192
	c.Assert(st, gc.Equals, expectState)
206
	c.Assert(st, gc.Equals, expectState)
353
193
	c.Assert(called, gc.Equals, 1)
207
	c.Assert(called, gc.Equals, 1)
354
@@ -209,16 +223,11 @@
355
209
	defer coretesting.MakeEmptyFakeHome(c).Restore()
223
	defer coretesting.MakeEmptyFakeHome(c).Restore()
356
210
	expectErr := fmt.Errorf("an error")
224
	expectErr := fmt.Errorf("an error")
357
211
	store := newConfigStoreWithError(expectErr)
225
	store := newConfigStoreWithError(expectErr)
360
212
	s.PatchValue(juju.APIOpen, panicAPIOpen)
226
	client, err := juju.NewAPIFromStore("noconfig", store, panicAPIOpen)
359
213
	client, err := juju.NewAPIFromStore("noconfig", store)
361
214
	c.Assert(err, gc.Equals, expectErr)
227
	c.Assert(err, gc.Equals, expectErr)
362
215
	c.Assert(client, gc.IsNil)
228
	c.Assert(client, gc.IsNil)
363
216
}
229
}
364
217
230
365
218
func panicAPIOpen(apiInfo *api.Info, opts api.DialOpts) (*api.State, error) {
366
219
	panic("api.Open called unexpectedly")
367
220
}
368
221
369
222
func (s *NewAPIClientSuite) TestWithInfoNoAddresses(c *gc.C) {
231
func (s *NewAPIClientSuite) TestWithInfoNoAddresses(c *gc.C) {
370
223
	defer coretesting.MakeEmptyFakeHome(c).Restore()
232
	defer coretesting.MakeEmptyFakeHome(c).Restore()
371
224
	store := newConfigStore("noconfig", &environInfo{
233
	store := newConfigStore("noconfig", &environInfo{
372
@@ -227,9 +236,7 @@
373
227
			CACert:    "certificated",
236
			CACert:    "certificated",
374
228
		},
237
		},
375
229
	})
238
	})
379
230
	s.PatchValue(juju.APIOpen, panicAPIOpen)
239
	st, err := juju.NewAPIFromStore("noconfig", store, panicAPIOpen)
377
231
378
232
	st, err := juju.NewAPIFromStore("noconfig", store)
380
233
	c.Assert(err, gc.ErrorMatches, `environment "noconfig" not found`)
240
	c.Assert(err, gc.ErrorMatches, `environment "noconfig" not found`)
381
234
	c.Assert(st, gc.IsNil)
241
	c.Assert(st, gc.IsNil)
382
235
}
242
}
383
@@ -243,11 +250,10 @@
384
243
	})
250
	})
385
244
251
386
245
	expectErr := fmt.Errorf("an error")
252
	expectErr := fmt.Errorf("an error")
388
246
	apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (*api.State, error) {
253
	apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
389
247
		return nil, expectErr
254
		return nil, expectErr
390
248
	}
255
	}
393
249
	s.PatchValue(juju.APIOpen, apiOpen)
256
	st, err := juju.NewAPIFromStore("noconfig", store, apiOpen)
392
250
	st, err := juju.NewAPIFromStore("noconfig", store)
394
251
	c.Assert(err, gc.Equals, expectErr)
257
	c.Assert(err, gc.Equals, expectErr)
395
252
	c.Assert(st, gc.IsNil)
258
	c.Assert(st, gc.IsNil)
396
253
}
259
}
397
@@ -258,27 +264,30 @@
398
258
	bootstrapEnv(c, coretesting.SampleEnvName, store)
264
	bootstrapEnv(c, coretesting.SampleEnvName, store)
399
259
	setEndpointAddress(c, store, coretesting.SampleEnvName, "infoapi.invalid")
265
	setEndpointAddress(c, store, coretesting.SampleEnvName, "infoapi.invalid")
400
260
266
402
261
	infoOpenedState := new(api.State)
267
	infoOpenedState := &mockAPIState{}
403
262
	infoEndpointOpened := make(chan struct{})
268
	infoEndpointOpened := make(chan struct{})
405
263
	cfgOpenedState := new(api.State)
269
	cfgOpenedState := &mockAPIState{}
406
264
	// On a sample run with no delay, the logic took 45ms to run, so
270
	// On a sample run with no delay, the logic took 45ms to run, so
407
265
	// we make the delay slightly more than that, so that if the
271
	// we make the delay slightly more than that, so that if the
408
266
	// logic doesn't delay at all, the test will fail reasonably consistently.
272
	// logic doesn't delay at all, the test will fail reasonably consistently.
409
267
	s.PatchValue(juju.ProviderConnectDelay, 50*time.Millisecond)
273
	s.PatchValue(juju.ProviderConnectDelay, 50*time.Millisecond)
411
268
	apiOpen := func(info *api.Info, opts api.DialOpts) (*api.State, error) {
274
	apiOpen := func(info *api.Info, opts api.DialOpts) (juju.APIState, error) {
412
269
		if info.Addrs[0] == "infoapi.invalid" {
275
		if info.Addrs[0] == "infoapi.invalid" {
413
270
			infoEndpointOpened <- struct{}{}
276
			infoEndpointOpened <- struct{}{}
414
271
			return infoOpenedState, nil
277
			return infoOpenedState, nil
415
272
		}
278
		}
416
273
		return cfgOpenedState, nil
279
		return cfgOpenedState, nil
417
274
	}
280
	}
418
275
	s.PatchValue(juju.APIOpen, apiOpen)
419
276
281
422
277
	stateClosed, restoreAPIClose := setAPIClosed()
282
	stateClosed := make(chan juju.APIState)
423
278
	defer restoreAPIClose.Restore()
283
	infoOpenedState.close = func(st juju.APIState) error {
424
284
		stateClosed <- st
425
285
		return nil
426
286
	}
427
287
	cfgOpenedState.close = infoOpenedState.close
428
279
288
429
280
	startTime := time.Now()
289
	startTime := time.Now()
431
281
	st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store)
290
	st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store, apiOpen)
432
282
	c.Assert(err, gc.IsNil)
291
	c.Assert(err, gc.IsNil)
433
283
	// The connection logic should wait for some time before opening
292
	// The connection logic should wait for some time before opening
434
284
	// the API from the configuration.
293
	// the API from the configuration.
435
@@ -320,13 +329,13 @@
436
320
	bootstrapEnv(c, coretesting.SampleEnvName, store)
329
	bootstrapEnv(c, coretesting.SampleEnvName, store)
437
321
	setEndpointAddress(c, store, coretesting.SampleEnvName, "infoapi.invalid")
330
	setEndpointAddress(c, store, coretesting.SampleEnvName, "infoapi.invalid")
438
322
331
440
323
	infoOpenedState := new(api.State)
332
	infoOpenedState := &mockAPIState{}
441
324
	infoEndpointOpened := make(chan struct{})
333
	infoEndpointOpened := make(chan struct{})
443
325
	cfgOpenedState := new(api.State)
334
	cfgOpenedState := &mockAPIState{}
444
326
	cfgEndpointOpened := make(chan struct{})
335
	cfgEndpointOpened := make(chan struct{})
445
327
336
446
328
	s.PatchValue(juju.ProviderConnectDelay, 0*time.Second)
337
	s.PatchValue(juju.ProviderConnectDelay, 0*time.Second)
448
329
	apiOpen := func(info *api.Info, opts api.DialOpts) (*api.State, error) {
338
	apiOpen := func(info *api.Info, opts api.DialOpts) (juju.APIState, error) {
449
330
		if info.Addrs[0] == "infoapi.invalid" {
339
		if info.Addrs[0] == "infoapi.invalid" {
450
331
			infoEndpointOpened <- struct{}{}
340
			infoEndpointOpened <- struct{}{}
451
332
			<-infoEndpointOpened
341
			<-infoEndpointOpened
452
@@ -336,14 +345,17 @@
453
336
		<-cfgEndpointOpened
345
		<-cfgEndpointOpened
454
337
		return cfgOpenedState, nil
346
		return cfgOpenedState, nil
455
338
	}
347
	}
456
339
	s.PatchValue(juju.APIOpen, apiOpen)
457
340
348
460
341
	stateClosed, restoreAPIClose := setAPIClosed()
349
	stateClosed := make(chan juju.APIState)
461
342
	defer restoreAPIClose.Restore()
350
	infoOpenedState.close = func(st juju.APIState) error {
462
351
		stateClosed <- st
463
352
		return nil
464
353
	}
465
354
	cfgOpenedState.close = infoOpenedState.close
466
343
355
467
344
	done := make(chan struct{})
356
	done := make(chan struct{})
468
345
	go func() {
357
	go func() {
470
346
		st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store)
358
		st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store, apiOpen)
471
347
		c.Check(err, gc.IsNil)
359
		c.Check(err, gc.IsNil)
472
348
		c.Check(st, gc.Equals, infoOpenedState)
360
		c.Check(st, gc.Equals, infoOpenedState)
473
349
		close(done)
361
		close(done)
474
@@ -387,14 +399,13 @@
475
387
	setEndpointAddress(c, store, coretesting.SampleEnvName, "infoapi.invalid")
399
	setEndpointAddress(c, store, coretesting.SampleEnvName, "infoapi.invalid")
476
388
400
477
389
	s.PatchValue(juju.ProviderConnectDelay, 0*time.Second)
401
	s.PatchValue(juju.ProviderConnectDelay, 0*time.Second)
479
390
	apiOpen := func(info *api.Info, opts api.DialOpts) (*api.State, error) {
402
	apiOpen := func(info *api.Info, opts api.DialOpts) (juju.APIState, error) {
480
391
		if info.Addrs[0] == "infoapi.invalid" {
403
		if info.Addrs[0] == "infoapi.invalid" {
481
392
			return nil, fmt.Errorf("info connect failed")
404
			return nil, fmt.Errorf("info connect failed")
482
393
		}
405
		}
483
394
		return nil, fmt.Errorf("config connect failed")
406
		return nil, fmt.Errorf("config connect failed")
484
395
	}
407
	}
487
396
	s.PatchValue(juju.APIOpen, apiOpen)
408
	st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store, apiOpen)
486
397
	st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store)
488
398
	c.Check(err, gc.ErrorMatches, "config connect failed")
409
	c.Check(err, gc.ErrorMatches, "config connect failed")
489
399
	c.Check(st, gc.IsNil)
410
	c.Check(st, gc.IsNil)
490
400
}
411
}
491
@@ -427,7 +438,10 @@
492
427
	err = os.Remove(osenv.JujuHomePath("environments.yaml"))
438
	err = os.Remove(osenv.JujuHomePath("environments.yaml"))
493
428
	c.Assert(err, gc.IsNil)
439
	c.Assert(err, gc.IsNil)
494
429
440
496
430
	st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store)
441
	apiOpen := func(*api.Info, api.DialOpts) (juju.APIState, error) {
497
442
		return &mockAPIState{}, nil
498
443
	}
499
444
	st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store, apiOpen)
500
431
	c.Check(err, gc.IsNil)
445
	c.Check(err, gc.IsNil)
501
432
	st.Close()
446
	st.Close()
502
433
}
447
}
503
@@ -455,7 +469,10 @@
504
455
	// Now we have info for envName2 which will actually
469
	// Now we have info for envName2 which will actually
505
456
	// cause a connection to the originally bootstrapped
470
	// cause a connection to the originally bootstrapped
506
457
	// state.
471
	// state.
508
458
	st, err := juju.NewAPIFromStore(envName2, store)
472
	apiOpen := func(*api.Info, api.DialOpts) (juju.APIState, error) {
509
473
		return &mockAPIState{}, nil
510
474
	}
511
475
	st, err := juju.NewAPIFromStore(envName2, store, apiOpen)
512
459
	c.Check(err, gc.IsNil)
476
	c.Check(err, gc.IsNil)
513
460
	st.Close()
477
	st.Close()
514
461
478
515
@@ -478,19 +495,6 @@
516
478
	c.Assert(envInfo.Name, gc.Equals, expectName)
495
	c.Assert(envInfo.Name, gc.Equals, expectName)
517
479
}
496
}
518
480
497
519
481
func setAPIClosed() (<-chan *api.State, testing.Restorer) {
520
482
	stateClosed := make(chan *api.State)
521
483
	apiClose := func(st *api.State) error {
522
484
		stateClosed <- st
523
485
		return nil
524
486
	}
525
487
	return stateClosed, testing.PatchValue(juju.APIClose, apiClose)
526
488
}
527
489
528
490
func updateSecretsNoop(_ environs.Environ, _ *api.State) error {
529
491
	return nil
530
492
}
531
493
532
494
// newConfigStoreWithError that will return the given
498
// newConfigStoreWithError that will return the given
533
495
// error from ReadInfo.
499
// error from ReadInfo.
534
496
func newConfigStoreWithError(err error) configstore.Storage {
500
func newConfigStoreWithError(err error) configstore.Storage {
535
497
501
536
=== modified file 'juju/export_test.go'
537
--- juju/export_test.go	2014-03-19 03:18:41 +0000
538
+++ juju/export_test.go	2014-03-31 12:32:07 +0000
539
@@ -1,8 +1,21 @@
540
1
package juju
1
package juju
541
2
2
542
3
import (
543
4
	"launchpad.net/juju-core/environs/configstore"
544
5
	"launchpad.net/juju-core/state/api"
545
6
)
546
7
547
3
var (
8
var (
548
4
	APIOpen              = &apiOpen
549
5
	APIClose             = &apiClose
550
6
	ProviderConnectDelay = &providerConnectDelay
9
	ProviderConnectDelay = &providerConnectDelay
551
7
	NewAPIFromStore      = newAPIFromStore
552
8
)
10
)
553
11
554
12
type APIState apiState
555
13
556
14
type APIOpenFunc func(*api.Info, api.DialOpts) (APIState, error)
557
15
558
16
func NewAPIFromStore(envName string, store configstore.Storage, f APIOpenFunc) (APIState, error) {
559
17
	apiOpen := func(info *api.Info, opts api.DialOpts) (apiState, error) {
560
18
		return f(info, opts)
561
19
	}
562
20
	return newAPIFromStore(envName, store, apiOpen)
563
21
}
564
9
22
565
=== added file 'juju/mock_test.go'
566
--- juju/mock_test.go	1970-01-01 00:00:00 +0000
567
+++ juju/mock_test.go	2014-03-31 12:32:07 +0000
568
@@ -0,0 +1,28 @@
569
1
package juju_test
570
2
571
3
import (
572
4
	"launchpad.net/juju-core/instance"
573
5
	"launchpad.net/juju-core/juju"
574
6
	"launchpad.net/juju-core/state/api"
575
7
)
576
8
577
9
type mockAPIState struct {
578
10
	close func(juju.APIState) error
579
11
580
12
	apiHostPorts [][]instance.HostPort
581
13
}
582
14
583
15
func (s *mockAPIState) Close() error {
584
16
	if s.close != nil {
585
17
		return s.close(s)
586
18
	}
587
19
	return nil
588
20
}
589
21
590
22
func (s *mockAPIState) APIHostPorts() [][]instance.HostPort {
591
23
	return s.apiHostPorts
592
24
}
593
25
594
26
func panicAPIOpen(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
595
27
	panic("api.Open called unexpectedly")
596
28
}
597
0
29
598
=== modified file 'state/api/apiclient.go'
599
--- state/api/apiclient.go	2014-03-19 03:18:41 +0000
600
+++ state/api/apiclient.go	2014-03-31 12:32:07 +0000
601
@@ -11,6 +11,7 @@
602
11
	"code.google.com/p/go.net/websocket"
11
	"code.google.com/p/go.net/websocket"
603
12
12
604
13
	"launchpad.net/juju-core/cert"
13
	"launchpad.net/juju-core/cert"
605
14
	"launchpad.net/juju-core/instance"
606
14
	"launchpad.net/juju-core/log"
15
	"launchpad.net/juju-core/log"
607
15
	"launchpad.net/juju-core/rpc"
16
	"launchpad.net/juju-core/rpc"
608
16
	"launchpad.net/juju-core/rpc/jsoncodec"
17
	"launchpad.net/juju-core/rpc/jsoncodec"
609
@@ -25,7 +26,13 @@
610
25
type State struct {
26
type State struct {
611
26
	client *rpc.Conn
27
	client *rpc.Conn
612
27
	conn   *websocket.Conn
28
	conn   *websocket.Conn
614
28
	addr   string
29
615
30
	// addr is the address used to connect to the API server.
616
31
	addr string
617
32
618
33
	// hostPorts is the API server addresses returned from Login,
619
34
	// which the client may cache and use for failover.
620
35
	hostPorts [][]instance.HostPort
621
29
36
622
30
	// authTag holds the authenticated entity's tag after login.
37
	// authTag holds the authenticated entity's tag after login.
623
31
	authTag string
38
	authTag string
624
@@ -189,7 +196,23 @@
625
189
	return s.client
196
	return s.client
626
190
}
197
}
627
191
198
629
192
// Addr returns the address used to connect to the RPC server.
199
// Addr returns the address used to connect to the API server.
630
193
func (s *State) Addr() string {
200
func (s *State) Addr() string {
631
194
	return s.addr
201
	return s.addr
632
195
}
202
}
633
203
634
204
// APIHostPorts returns addresses that may be used to connect
635
205
// to the API server, including the address used to connect.
636
206
//
637
207
// The addresses are scoped (public, cloud-internal, etc.), so
638
208
// the client may choose which addresses to attempt. For the
639
209
// Juju CLI, all addresses must be attempted, as the CLI may
640
210
// be invoked both within and outside the environment (think
641
211
// private clouds).
642
212
func (s *State) APIHostPorts() [][]instance.HostPort {
643
213
	hostPorts := make([][]instance.HostPort, len(s.hostPorts))
644
214
	for i, server := range s.hostPorts {
645
215
		hostPorts[i] = append([]instance.HostPort{}, server...)
646
216
	}
647
217
	return hostPorts
648
218
}
649
196
219
650
=== modified file 'state/api/params/params.go'
651
--- state/api/params/params.go	2014-03-28 13:31:26 +0000
652
+++ state/api/params/params.go	2014-03-31 12:32:07 +0000
653
@@ -640,6 +640,11 @@
654
640
	Servers [][]instance.HostPort
640
	Servers [][]instance.HostPort
655
641
}
641
}
656
642
642
657
643
// LoginResult holds the result of a Login call.
658
644
type LoginResult struct {
659
645
	Servers [][]instance.HostPort
660
646
}
661
647
662
643
// EnsureAvailability contains arguments for
648
// EnsureAvailability contains arguments for
663
644
// the EnsureAvailability client API call.
649
// the EnsureAvailability client API call.
664
645
type EnsureAvailability struct {
650
type EnsureAvailability struct {
665
646
651
666
=== modified file 'state/api/state.go'
667
--- state/api/state.go	2014-02-27 05:24:43 +0000
668
+++ state/api/state.go	2014-03-31 12:32:07 +0000
669
@@ -4,6 +4,10 @@
670
4
package api
4
package api
671
5
5
672
6
import (
6
import (
673
7
	"net"
674
8
	"strconv"
675
9
676
10
	"launchpad.net/juju-core/instance"
677
7
	"launchpad.net/juju-core/state/api/agent"
11
	"launchpad.net/juju-core/state/api/agent"
678
8
	"launchpad.net/juju-core/state/api/charmrevisionupdater"
12
	"launchpad.net/juju-core/state/api/charmrevisionupdater"
679
9
	"launchpad.net/juju-core/state/api/deployer"
13
	"launchpad.net/juju-core/state/api/deployer"
680
@@ -24,17 +28,54 @@
681
24
// method is usually called automatically by Open. The machine nonce
28
// method is usually called automatically by Open. The machine nonce
682
25
// should be empty unless logging in as a machine agent.
29
// should be empty unless logging in as a machine agent.
683
26
func (st *State) Login(tag, password, nonce string) error {
30
func (st *State) Login(tag, password, nonce string) error {
684
31
	var result params.LoginResult
685
27
	err := st.Call("Admin", "", "Login", &params.Creds{
32
	err := st.Call("Admin", "", "Login", &params.Creds{
686
28
		AuthTag:  tag,
33
		AuthTag:  tag,
687
29
		Password: password,
34
		Password: password,
688
30
		Nonce:    nonce,
35
		Nonce:    nonce,
690
31
	}, nil)
36
	}, &result)
691
32
	if err == nil {
37
	if err == nil {
692
33
		st.authTag = tag
38
		st.authTag = tag
693
39
		hostPorts, err := addAddress(result.Servers, st.addr)
694
40
		if err != nil {
695
41
			st.Close()
696
42
			return err
697
43
		}
698
44
		st.hostPorts = hostPorts
699
34
	}
45
	}
700
35
	return err
46
	return err
701
36
}
47
}
702
37
48
703
49
// addAddress appends a new server derived from the given
704
50
// address to servers if the address is not already found
705
51
// there.
706
52
func addAddress(servers [][]instance.HostPort, addr string) ([][]instance.HostPort, error) {
707
53
	for _, server := range servers {
708
54
		for _, hostPort := range server {
709
55
			if hostPort.NetAddr() == addr {
710
56
				return servers, nil
711
57
			}
712
58
		}
713
59
	}
714
60
	host, portString, err := net.SplitHostPort(addr)
715
61
	if err != nil {
716
62
		return nil, err
717
63
	}
718
64
	port, err := strconv.Atoi(portString)
719
65
	if err != nil {
720
66
		return nil, err
721
67
	}
722
68
	hostPort := instance.HostPort{
723
69
		Address: instance.Address{
724
70
			Value:        host,
725
71
			Type:         instance.DeriveAddressType(host),
726
72
			NetworkScope: instance.NetworkUnknown,
727
73
		},
728
74
		Port: port,
729
75
	}
730
76
	return append(servers, []instance.HostPort{hostPort}), nil
731
77
}
732
78
733
38
// Client returns an object that can be used
79
// Client returns an object that can be used
734
39
// to access client-specific functionality.
80
// to access client-specific functionality.
735
40
func (st *State) Client() *Client {
81
func (st *State) Client() *Client {
736
41
82
737
=== modified file 'state/apiserver/admin.go'
738
--- state/apiserver/admin.go	2014-01-17 19:33:42 +0000
739
+++ state/apiserver/admin.go	2014-03-31 12:32:07 +0000
740
@@ -63,16 +63,16 @@
741
63
// Login logs in with the provided credentials.
63
// Login logs in with the provided credentials.
742
64
// All subsequent requests on the connection will
64
// All subsequent requests on the connection will
743
65
// act as the authenticated user.
65
// act as the authenticated user.
745
66
func (a *srvAdmin) Login(c params.Creds) error {
66
func (a *srvAdmin) Login(c params.Creds) (params.LoginResult, error) {
746
67
	a.mu.Lock()
67
	a.mu.Lock()
747
68
	defer a.mu.Unlock()
68
	defer a.mu.Unlock()
748
69
	if a.loggedIn {
69
	if a.loggedIn {
749
70
		// This can only happen if Login is called concurrently.
70
		// This can only happen if Login is called concurrently.
751
71
		return errAlreadyLoggedIn
71
		return params.LoginResult{}, errAlreadyLoggedIn
752
72
	}
72
	}
753
73
	entity, err := checkCreds(a.root.srv.state, c)
73
	entity, err := checkCreds(a.root.srv.state, c)
754
74
	if err != nil {
74
	if err != nil {
756
75
		return err
75
		return params.LoginResult{}, err
757
76
	}
76
	}
758
77
	if a.reqNotifier != nil {
77
	if a.reqNotifier != nil {
759
78
		a.reqNotifier.login(entity.Tag())
78
		a.reqNotifier.login(entity.Tag())
760
@@ -81,11 +81,18 @@
761
81
	// to serve to them.
81
	// to serve to them.
762
82
	newRoot, err := a.apiRootForEntity(entity, c)
82
	newRoot, err := a.apiRootForEntity(entity, c)
763
83
	if err != nil {
83
	if err != nil {
766
84
		return err
84
		return params.LoginResult{}, err
767
85
	}
85
	}
768
86
769
87
	// Fetch the API server addresses from state.
770
88
	hostPorts, err := a.root.srv.state.APIHostPorts()
771
89
	if err != nil {
772
90
		return params.LoginResult{}, err
773
91
	}
774
92
	logger.Debugf("hostPorts: %v", hostPorts)
775
86
93
776
87
	a.root.rpcConn.Serve(newRoot, serverError)
94
	a.root.rpcConn.Serve(newRoot, serverError)
778
88
	return nil
95
	return params.LoginResult{hostPorts}, nil
779
89
}
96
}
780
90
97
781
91
func checkCreds(st *state.State, c params.Creds) (taggedAuthenticator, error) {
98
func checkCreds(st *state.State, c params.Creds) (taggedAuthenticator, error) {
782
92
99
783
=== modified file 'state/apiserver/login_test.go'
784
--- state/apiserver/login_test.go	2014-03-13 13:42:50 +0000
785
+++ state/apiserver/login_test.go	2014-03-31 12:32:07 +0000
786
@@ -4,10 +4,14 @@
787
4
package apiserver_test
4
package apiserver_test
788
5
5
789
6
import (
6
import (
790
7
	"net"
791
8
	"strconv"
792
9
793
7
	"github.com/juju/loggo"
10
	"github.com/juju/loggo"
794
8
	jc "github.com/juju/testing/checkers"
11
	jc "github.com/juju/testing/checkers"
795
9
	gc "launchpad.net/gocheck"
12
	gc "launchpad.net/gocheck"
796
10
13
797
14
	"launchpad.net/juju-core/instance"
798
11
	jujutesting "launchpad.net/juju-core/juju/testing"
15
	jujutesting "launchpad.net/juju-core/juju/testing"
799
12
	"launchpad.net/juju-core/state"
16
	"launchpad.net/juju-core/state"
800
13
	"launchpad.net/juju-core/state/api"
17
	"launchpad.net/juju-core/state/api"
801
@@ -160,8 +164,74 @@
802
160
		// Now that we are logged in, we see the entity's tag
164
		// Now that we are logged in, we see the entity's tag
803
161
		// [0-9.umns] is to handle timestamps that are ns, us, ms, or s
165
		// [0-9.umns] is to handle timestamps that are ns, us, ms, or s
804
162
		// long, though we expect it to be in the 'ms' range.
166
		// long, though we expect it to be in the 'ms' range.
806
163
		`-> \[[0-9A-F]+\] machine-0 [0-9.]+[umn]?s {"RequestId":1,"Response":{}} Admin\[""\].Login`,
167
		`-> \[[0-9A-F]+\] machine-0 [0-9.]+[umn]?s {"RequestId":1,"Response":{"Servers":\[\]}} Admin\[""\].Login`,
807
164
		`<- \[[0-9A-F]+\] machine-0 {"RequestId":2,"Type":"Machiner","Request":"Life","Params":{"Entities":\[{"Tag":"machine-0"}\]}}`,
168
		`<- \[[0-9A-F]+\] machine-0 {"RequestId":2,"Type":"Machiner","Request":"Life","Params":{"Entities":\[{"Tag":"machine-0"}\]}}`,
808
165
		`-> \[[0-9A-F]+\] machine-0 [0-9.umns]+ {"RequestId":2,"Response":{"Results":\[{"Life":"alive","Error":null}\]}} Machiner\[""\]\.Life`,
169
		`-> \[[0-9A-F]+\] machine-0 [0-9.umns]+ {"RequestId":2,"Response":{"Results":\[{"Life":"alive","Error":null}\]}} Machiner\[""\]\.Life`,
809
166
	})
170
	})
810
167
}
171
}
811
172
812
173
func (s *loginSuite) TestLoginAddrs(c *gc.C) {
813
174
	machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
814
175
	c.Assert(err, gc.IsNil)
815
176
	err = machine.SetProvisioned("foo", "fake_nonce", nil)
816
177
	c.Assert(err, gc.IsNil)
817
178
	password, err := utils.RandomPassword()
818
179
	c.Assert(err, gc.IsNil)
819
180
	err = machine.SetPassword(password)
820
181
	c.Assert(err, gc.IsNil)
821
182
	info, cleanup := s.setupServer(c)
822
183
	defer cleanup()
823
184
	info.Tag = machine.Tag()
824
185
	info.Password = password
825
186
	info.Nonce = "fake_nonce"
826
187
827
188
	// Initially just the address we connect with is returned,
828
189
	// despite there being no APIHostPorts in state.
829
190
	connectedAddr, hostPorts := s.loginHostPorts(c, info)
830
191
	connectedAddrHost, connectedAddrPortString, err := net.SplitHostPort(connectedAddr)
831
192
	c.Assert(err, gc.IsNil)
832
193
	connectedAddrPort, err := strconv.Atoi(connectedAddrPortString)
833
194
	c.Assert(err, gc.IsNil)
834
195
	connectedAddrHostPorts := [][]instance.HostPort{
835
196
		[]instance.HostPort{{
836
197
			instance.NewAddress(connectedAddrHost),
837
198
			connectedAddrPort,
838
199
		}},
839
200
	}
840
201
	c.Assert(hostPorts, gc.DeepEquals, connectedAddrHostPorts)
841
202
842
203
	// After storing APIHostPorts in state, Login should store
843
204
	// all of them and the address we connected with.
844
205
	server1Addresses := []instance.Address{{
845
206
		Value:        "server-1",
846
207
		Type:         instance.HostName,
847
208
		NetworkScope: instance.NetworkPublic,
848
209
	}, {
849
210
		Value:        "10.0.0.1",
850
211
		Type:         instance.Ipv4Address,
851
212
		NetworkName:  "internal",
852
213
		NetworkScope: instance.NetworkCloudLocal,
853
214
	}}
854
215
	server2Addresses := []instance.Address{{
855
216
		Value:        "::1",
856
217
		Type:         instance.Ipv6Address,
857
218
		NetworkName:  "loopback",
858
219
		NetworkScope: instance.NetworkMachineLocal,
859
220
	}}
860
221
	stateAPIHostPorts := [][]instance.HostPort{
861
222
		instance.AddressesWithPort(server1Addresses, 123),
862
223
		instance.AddressesWithPort(server2Addresses, 456),
863
224
	}
864
225
	err = s.State.SetAPIHostPorts(stateAPIHostPorts)
865
226
	c.Assert(err, gc.IsNil)
866
227
	connectedAddr, hostPorts = s.loginHostPorts(c, info)
867
228
	stateAPIHostPorts = append(stateAPIHostPorts, connectedAddrHostPorts...)
868
229
	c.Assert(hostPorts, gc.DeepEquals, stateAPIHostPorts)
869
230
}
870
231
871
232
func (s *loginSuite) loginHostPorts(c *gc.C, info *api.Info) (connectedAddr string, hostPorts [][]instance.HostPort) {
872
233
	st, err := api.Open(info, fastDialOpts)
873
234
	c.Assert(err, gc.IsNil)
874
235
	defer st.Close()
875
236
	return st.Addr(), st.APIHostPorts()
876
237
}
Status:	Merged
Approved by:	Andrew Wilkins on 2014-03-31
Approved revision:	no longer in the source branch.
Merged at revision:	2517
Proposed branch:	lp:~axwalk/juju-core/client-cache-apihostports
Merge into:	lp:~go-bot/juju-core/trunk
Prerequisite:	lp:~axwalk/juju-core/apihostports-api
Diff against target:	876 lines (+350/-109) 9 files modified juju/api.go (+92/-42) juju/apiconn_test.go (+58/-54) juju/export_test.go (+16/-3) juju/mock_test.go (+28/-0) state/api/apiclient.go (+25/-2) state/api/params/params.go (+5/-0) state/api/state.go (+42/-1) state/apiserver/admin.go (+13/-6) state/apiserver/login_test.go (+71/-1)
To merge this branch:	bzr merge lp:~axwalk/juju-core/client-cache-apihostports
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Juju Engineering		2014-03-28	Pending
Review via email: mp+213217@code.launchpad.net