1
=== modified file 'state/api/apiclient.go'
2
--- state/api/apiclient.go	2014-04-09 15:17:04 +0000
3
+++ state/api/apiclient.go	2014-04-10 09:38:03 +0000
4
@@ -56,6 +56,10 @@
5
56
	// serverRoot holds the cached API server address and port we used
56
	// serverRoot holds the cached API server address and port we used
6
57
	// to login, with a https:// prefix.
57
	// to login, with a https:// prefix.
7
58
	serverRoot string
58
	serverRoot string
8
59
9
60
	// certPool holds the cert pool that is used to authenticate the tls
10
61
	// connections to the API.
11
62
	certPool *x509.CertPool
12
59
}
63
}
13
60
64
14
61
// Info encapsulates information about a server holding juju state and
65
// Info encapsulates information about a server holding juju state and
15
@@ -151,6 +155,7 @@
16
151
		serverRoot: "https://" + conn.Config().Location.Host,
155
		serverRoot: "https://" + conn.Config().Location.Host,
17
152
		tag:        info.Tag,
156
		tag:        info.Tag,
18
153
		password:   info.Password,
157
		password:   info.Password,
19
158
		certPool:   pool,
20
154
	}
159
	}
21
155
	if info.Tag != "" || info.Password != "" {
160
	if info.Tag != "" || info.Password != "" {
22
156
		if err := st.Login(info.Tag, info.Password, info.Nonce); err != nil {
161
		if err := st.Login(info.Tag, info.Password, info.Nonce); err != nil {
23
157
162
24
=== modified file 'state/api/client.go'
25
--- state/api/client.go	2014-04-10 08:47:38 +0000
26
+++ state/api/client.go	2014-04-10 09:38:03 +0000
27
@@ -4,14 +4,20 @@
28
4
package api
4
package api
29
5
5
30
6
import (
6
import (
31
7
	"crypto/tls"
32
7
	"encoding/json"
8
	"encoding/json"
33
8
	"fmt"
9
	"fmt"
34
10
	"io"
35
9
	"io/ioutil"
11
	"io/ioutil"
36
10
	"net/http"
12
	"net/http"
37
13
	"net/url"
38
11
	"os"
14
	"os"
39
12
	"strings"
15
	"strings"
40
13
	"time"
16
	"time"
41
14
17
42
18
	"code.google.com/p/go.net/websocket"
43
19
	"github.com/juju/loggo"
44
20
45
15
	"launchpad.net/juju-core/charm"
21
	"launchpad.net/juju-core/charm"
46
16
	"launchpad.net/juju-core/constraints"
22
	"launchpad.net/juju-core/constraints"
47
17
	"launchpad.net/juju-core/instance"
23
	"launchpad.net/juju-core/instance"
48
@@ -703,3 +709,128 @@
49
703
	}
709
	}
50
704
	return c.call("EnsureAvailability", args, nil)
710
	return c.call("EnsureAvailability", args, nil)
51
705
}
711
}
52
712
53
713
// AgentVersion reports the version number of the api server.
54
714
func (c *Client) AgentVersion() (version.Number, error) {
55
715
	var result params.AgentVersionResult
56
716
	if err := c.call("AgentVersion", nil, &result); err != nil {
57
717
		return version.Number{}, err
58
718
	}
59
719
	return result.Version, nil
60
720
}
61
721
62
722
// websocketDialConfig is called instead of websocket.DialConfig so we can
63
723
// override it in tests.
64
724
var websocketDialConfig = func(config *websocket.Config) (io.ReadCloser, error) {
65
725
	return websocket.DialConfig(config)
66
726
}
67
727
68
728
type connectionError struct {
69
729
	error
70
730
}
71
731
72
732
// IsConnectionError reports whether the error is a connection error.
73
733
func IsConnectionError(err error) bool {
74
734
	_, ok := err.(*connectionError)
75
735
	return ok
76
736
}
77
737
78
738
// DebugLogParams holds parameters for WatchDebugLog that control the
79
739
// filtering of the log messages. If the structure is zero initialized, the
80
740
// entire log file is sent back starting from the end, and until the user
81
741
// closes the connection.
82
742
type DebugLogParams struct {
83
743
	// IncludeEntity lists entity tags to include in the response. Tags may
84
744
	// finish with a '*' to match a prefix e.g.: unit-mysql-*, machine-2. If
85
745
	// none are set, then all lines are considered included.
86
746
	IncludeEntity []string
87
747
	// IncludeModule lists logging modules to include in the response. If none
88
748
	// are set all modules are considered included.  If a module is specified,
89
749
	// all the submodules also match.
90
750
	IncludeModule []string
91
751
	// ExcludeEntity lists entity tags to exclude from the response. As with
92
752
	// IncludeEntity the values may finish with a '*'.
93
753
	ExcludeEntity []string
94
754
	// ExcludeModule lists logging modules to exclude from the resposne. If a
95
755
	// module is specified, all the submodules are also excluded.
96
756
	ExcludeModule []string
97
757
	// Limit defines the maximum number of lines to return. Once this many
98
758
	// have been sent, the socket is closed.  If zero, all filtered lines are
99
759
	// sent down the connection until the client closes the connection.
100
760
	Limit uint
101
761
	// Backlog tells the server to try to go back this many lines before
102
762
	// starting filtering. If backlog is zero and replay is false, then there
103
763
	// may be an initial delay until the next matching log message is written.
104
764
	Backlog uint
105
765
	// Level specifies the minimum logging level to be sent back in the response.
106
766
	Level loggo.Level
107
767
	// Replay tells the server to start at the start of the log file rather
108
768
	// than the end. If replay is true, backlog is ignored.
109
769
	Replay bool
110
770
}
111
771
112
772
// WatchDebugLog returns a ReadCloser that the caller can read the log lines
113
773
// from. Only log lines that match the filtering specified in the
114
774
// DebugLogParams are returned. It returns an error that satisfies
115
775
// IsConnectionError when the connection cannot be made.
116
776
func (c *Client) WatchDebugLog(args DebugLogParams) (io.ReadCloser, error) {
117
777
	// The websocket connection just hangs if the server doesn't have the log
118
778
	// end point. So do a version check, as version was added at the same time
119
779
	// as the remote end point.
120
780
	_, err := c.AgentVersion()
121
781
	if err != nil {
122
782
		return nil, &connectionError{fmt.Errorf("server doesn't support debug log websocket")}
123
783
	}
124
784
	// Prepare URL.
125
785
	attrs := url.Values{}
126
786
	if args.Replay {
127
787
		attrs.Set("replay", fmt.Sprint(args.Replay))
128
788
	}
129
789
	if args.Limit > 0 {
130
790
		attrs.Set("maxLines", fmt.Sprint(args.Limit))
131
791
	}
132
792
	if args.Backlog > 0 {
133
793
		attrs.Set("backlog", fmt.Sprint(args.Backlog))
134
794
	}
135
795
	if args.Level != loggo.UNSPECIFIED {
136
796
		attrs.Set("level", fmt.Sprint(args.Level))
137
797
	}
138
798
	attrs["includeEntity"] = args.IncludeEntity
139
799
	attrs["includeModule"] = args.IncludeModule
140
800
	attrs["excludeEntity"] = args.ExcludeEntity
141
801
	attrs["excludeModule"] = args.ExcludeModule
142
802
143
803
	target := url.URL{
144
804
		Scheme:   "wss",
145
805
		Host:     c.st.addr,
146
806
		Path:     "/log",
147
807
		RawQuery: attrs.Encode(),
148
808
	}
149
809
	cfg, err := websocket.NewConfig(target.String(), "http://localhost/")
150
810
	cfg.Header = utils.BasicAuthHeader(c.st.tag, c.st.password)
151
811
	cfg.TlsConfig = &tls.Config{RootCAs: c.st.certPool, ServerName: "anything"}
152
812
	connection, err := websocketDialConfig(cfg)
153
813
	if err != nil {
154
814
		return nil, &connectionError{err}
155
815
	}
156
816
	// Read the initial error and translate to a real error.
157
817
	// Read up to the first new line character. We can't use bufio here as it
158
818
	// reads too much from the reader.
159
819
	line := make([]byte, 4096)
160
820
	n, err := connection.Read(line)
161
821
	if err != nil {
162
822
		return nil, fmt.Errorf("unable to read initial response: %v", err)
163
823
	}
164
824
	line = line[0:n]
165
825
166
826
	logger.Debugf("initial line: %q", line)
167
827
	var errResult params.ErrorResult
168
828
	err = json.Unmarshal(line, &errResult)
169
829
	if err != nil {
170
830
		return nil, fmt.Errorf("unable to unmarshal initial response: %v", err)
171
831
	}
172
832
	if errResult.Error != nil {
173
833
		return nil, errResult.Error
174
834
	}
175
835
	return connection, nil
176
836
}
177
706
837
178
=== modified file 'state/api/client_test.go'
179
--- state/api/client_test.go	2014-04-01 15:28:49 +0000
180
+++ state/api/client_test.go	2014-04-10 09:38:03 +0000
181
@@ -4,10 +4,19 @@
182
4
package api_test
4
package api_test
183
5
5
184
6
import (
6
import (
185
7
	"bufio"
186
8
	"bytes"
187
9
	"encoding/json"
188
7
	"fmt"
10
	"fmt"
189
11
	"io"
190
12
	"io/ioutil"
191
8
	"net"
13
	"net"
192
9
	"net/http"
14
	"net/http"
193
15
	"net/url"
194
16
	"strings"
195
10
17
196
18
	"code.google.com/p/go.net/websocket"
197
19
	"github.com/juju/loggo"
198
11
	jc "github.com/juju/testing/checkers"
20
	jc "github.com/juju/testing/checkers"
199
12
	gc "launchpad.net/gocheck"
21
	gc "launchpad.net/gocheck"
200
13
22
201
@@ -83,3 +92,114 @@
202
83
	_, err = client.AddLocalCharm(curl, charmArchive)
92
	_, err = client.AddLocalCharm(curl, charmArchive)
203
84
	c.Assert(err, jc.Satisfies, params.IsCodeNotImplemented)
93
	c.Assert(err, jc.Satisfies, params.IsCodeNotImplemented)
204
85
}
94
}
205
95
206
96
func (s *clientSuite) TestWatchDebugLogConnected(c *gc.C) {
207
97
	// Shows both the unmarshalling of a real error, and
208
98
	// that the api server is connected.
209
99
	client := s.APIState.Client()
210
100
	reader, err := client.WatchDebugLog(api.DebugLogParams{})
211
101
	c.Assert(err, gc.ErrorMatches, "cannot open log file: .*")
212
102
	c.Assert(reader, gc.IsNil)
213
103
}
214
104
215
105
func (s *clientSuite) TestConnectionErrorBadConnection(c *gc.C) {
216
106
	s.PatchValue(api.WebsocketDialConfig, func(_ *websocket.Config) (io.ReadCloser, error) {
217
107
		return nil, fmt.Errorf("bad connection")
218
108
	})
219
109
	client := s.APIState.Client()
220
110
	reader, err := client.WatchDebugLog(api.DebugLogParams{})
221
111
	c.Assert(err, gc.ErrorMatches, "bad connection")
222
112
	c.Assert(reader, gc.IsNil)
223
113
}
224
114
225
115
func (s *clientSuite) TestConnectionErrorNoData(c *gc.C) {
226
116
	s.PatchValue(api.WebsocketDialConfig, func(_ *websocket.Config) (io.ReadCloser, error) {
227
117
		return ioutil.NopCloser(&bytes.Buffer{}), nil
228
118
	})
229
119
	client := s.APIState.Client()
230
120
	reader, err := client.WatchDebugLog(api.DebugLogParams{})
231
121
	c.Assert(err, gc.ErrorMatches, "unable to read initial response: EOF")
232
122
	c.Assert(reader, gc.IsNil)
233
123
}
234
124
235
125
func (s *clientSuite) TestConnectionErrorBadData(c *gc.C) {
236
126
	s.PatchValue(api.WebsocketDialConfig, func(_ *websocket.Config) (io.ReadCloser, error) {
237
127
		junk := strings.NewReader("junk\n")
238
128
		return ioutil.NopCloser(junk), nil
239
129
	})
240
130
	client := s.APIState.Client()
241
131
	reader, err := client.WatchDebugLog(api.DebugLogParams{})
242
132
	c.Assert(err, gc.ErrorMatches, "unable to unmarshal initial response: .*")
243
133
	c.Assert(reader, gc.IsNil)
244
134
}
245
135
246
136
func (s *clientSuite) TestConnectionErrorReadError(c *gc.C) {
247
137
	s.PatchValue(api.WebsocketDialConfig, func(_ *websocket.Config) (io.ReadCloser, error) {
248
138
		err := fmt.Errorf("bad read")
249
139
		return ioutil.NopCloser(&badReader{err}), nil
250
140
	})
251
141
	client := s.APIState.Client()
252
142
	reader, err := client.WatchDebugLog(api.DebugLogParams{})
253
143
	c.Assert(err, gc.ErrorMatches, "unable to read initial response: bad read")
254
144
	c.Assert(reader, gc.IsNil)
255
145
}
256
146
257
147
func (s *clientSuite) TestParamsEncoded(c *gc.C) {
258
148
	s.PatchValue(api.WebsocketDialConfig, echoURL(c))
259
149
260
150
	params := api.DebugLogParams{
261
151
		IncludeEntity: []string{"a", "b"},
262
152
		IncludeModule: []string{"c", "d"},
263
153
		ExcludeEntity: []string{"e", "f"},
264
154
		ExcludeModule: []string{"g", "h"},
265
155
		Limit:         100,
266
156
		Backlog:       200,
267
157
		Level:         loggo.ERROR,
268
158
		Replay:        true,
269
159
	}
270
160
271
161
	client := s.APIState.Client()
272
162
	reader, err := client.WatchDebugLog(params)
273
163
	c.Assert(err, gc.IsNil)
274
164
275
165
	bufReader := bufio.NewReader(reader)
276
166
	location, err := bufReader.ReadString('\n')
277
167
	c.Assert(err, gc.IsNil)
278
168
	connectUrl, err := url.Parse(strings.TrimSpace(location))
279
169
	c.Assert(err, gc.IsNil)
280
170
281
171
	values := connectUrl.Query()
282
172
	c.Assert(values, jc.DeepEquals, url.Values{
283
173
		"includeEntity": params.IncludeEntity,
284
174
		"includeModule": params.IncludeModule,
285
175
		"excludeEntity": params.ExcludeEntity,
286
176
		"excludeModule": params.ExcludeModule,
287
177
		"maxLines":      {"100"},
288
178
		"backlog":       {"200"},
289
179
		"level":         {"ERROR"},
290
180
		"replay":        {"true"},
291
181
	})
292
182
}
293
183
294
184
// badReader raises err when Read is called.
295
185
type badReader struct {
296
186
	err error
297
187
}
298
188
299
189
func (r *badReader) Read(p []byte) (n int, err error) {
300
190
	return 0, r.err
301
191
}
302
192
303
193
func echoURL(c *gc.C) func(*websocket.Config) (io.ReadCloser, error) {
304
194
	response := &params.ErrorResult{}
305
195
	message, err := json.Marshal(response)
306
196
	c.Assert(err, gc.IsNil)
307
197
	return func(config *websocket.Config) (io.ReadCloser, error) {
308
198
		pr, pw := io.Pipe()
309
199
		go func() {
310
200
			fmt.Fprintf(pw, "%s\n", message)
311
201
			fmt.Fprintf(pw, "%s\n", config.Location)
312
202
		}()
313
203
		return pr, nil
314
204
	}
315
205
}
316
86
206
317
=== modified file 'state/api/export_test.go'
318
--- state/api/export_test.go	2014-04-01 03:13:49 +0000
319
+++ state/api/export_test.go	2014-04-10 09:38:03 +0000
320
@@ -5,6 +5,8 @@
321
5
5
322
6
var (
6
var (
323
7
	NewWebsocketDialer = newWebsocketDialer
7
	NewWebsocketDialer = newWebsocketDialer
324
8
325
9
	WebsocketDialConfig = &websocketDialConfig
326
8
)
10
)
327
9
11
328
10
// SetServerRoot allows changing the URL to the internal API server
12
// SetServerRoot allows changing the URL to the internal API server
329
11
13
330
=== modified file 'state/api/params/internal.go'
331
--- state/api/params/internal.go	2014-04-09 15:08:51 +0000
332
+++ state/api/params/internal.go	2014-04-10 09:38:03 +0000
333
@@ -572,3 +572,9 @@
334
572
type RunResults struct {
572
type RunResults struct {
335
573
	Results []RunResult
573
	Results []RunResult
336
574
}
574
}
337
575
338
576
// AgentVersionResult is used to return the current version number of the
339
577
// agent running the API server.
340
578
type AgentVersionResult struct {
341
579
	Version version.Number
342
580
}
343
575
581
344
=== modified file 'state/apiserver/client/client.go'
345
--- state/apiserver/client/client.go	2014-04-10 08:47:38 +0000
346
+++ state/apiserver/client/client.go	2014-04-10 09:38:03 +0000
347
@@ -28,6 +28,7 @@
348
28
	"launchpad.net/juju-core/state/statecmd"
28
	"launchpad.net/juju-core/state/statecmd"
349
29
	coretools "launchpad.net/juju-core/tools"
29
	coretools "launchpad.net/juju-core/tools"
350
30
	"launchpad.net/juju-core/utils"
30
	"launchpad.net/juju-core/utils"
351
31
	"launchpad.net/juju-core/version"
352
31
)
32
)
353
32
33
354
33
var logger = loggo.GetLogger("juju.state.apiserver.client")
34
var logger = loggo.GetLogger("juju.state.apiserver.client")
355
@@ -782,6 +783,11 @@
356
782
	return changes, nil
783
	return changes, nil
357
783
}
784
}
358
784
785
359
786
// AgentVersion returns the current version that the API server is running.
360
787
func (c *Client) AgentVersion() (params.AgentVersionResult, error) {
361
788
	return params.AgentVersionResult{Version: version.Current.Number}, nil
362
789
}
363
790
364
785
// EnvironmentGet implements the server-side part of the
791
// EnvironmentGet implements the server-side part of the
365
786
// get-environment CLI command.
792
// get-environment CLI command.
366
787
func (c *Client) EnvironmentGet() (params.EnvironmentGetResults, error) {
793
func (c *Client) EnvironmentGet() (params.EnvironmentGetResults, error) {
367
788
794
368
=== modified file 'state/apiserver/client/client_test.go'
369
--- state/apiserver/client/client_test.go	2014-04-10 08:47:38 +0000
370
+++ state/apiserver/client/client_test.go	2014-04-10 09:38:03 +0000
371
@@ -2211,3 +2211,11 @@
372
2211
	c.Assert(err, gc.IsNil)
2211
	c.Assert(err, gc.IsNil)
373
2212
	c.Assert(apiHostPorts, gc.DeepEquals, stateAPIHostPorts)
2212
	c.Assert(apiHostPorts, gc.DeepEquals, stateAPIHostPorts)
374
2213
}
2213
}
375
2214
376
2215
func (s *clientSuite) TestClientAgentVersion(c *gc.C) {
377
2216
	current := version.MustParse("1.2.0")
378
2217
	s.PatchValue(&version.Current.Number, current)
379
2218
	result, err := s.APIState.Client().AgentVersion()
380
2219
	c.Assert(err, gc.IsNil)
381
2220
	c.Assert(result, gc.Equals, current)
382
2221
}
383
2214
2222
384
=== modified file 'state/apiserver/debuglog.go'
385
--- state/apiserver/debuglog.go	2014-04-07 04:58:59 +0000
386
+++ state/apiserver/debuglog.go	2014-04-10 09:38:03 +0000
387
@@ -41,7 +41,7 @@
388
41
//      - as with include, it may finish with a '*'
41
//      - as with include, it may finish with a '*'
389
42
//   excludeModule -> []string - lists logging modules to exclude from the response
42
//   excludeModule -> []string - lists logging modules to exclude from the response
390
43
//   limit -> uint - show *at most* this many lines
43
//   limit -> uint - show *at most* this many lines
392
44
//   backtrack -> uint
44
//   backlog -> uint
393
45
//      - go back this many lines from the end before starting to filter
45
//      - go back this many lines from the end before starting to filter
394
46
//      - has no meaning if 'replay' is true
46
//      - has no meaning if 'replay' is true
395
47
//   level -> string one of [TRACE, DEBUG, INFO, WARNING, ERROR]
47
//   level -> string one of [TRACE, DEBUG, INFO, WARNING, ERROR]
396
48
48
397
=== modified file 'state/apiserver/debuglog_test.go'
398
--- state/apiserver/debuglog_test.go	2014-04-07 04:33:18 +0000
399
+++ state/apiserver/debuglog_test.go	2014-04-10 09:38:03 +0000
400
@@ -7,7 +7,6 @@
401
7
	"bufio"
7
	"bufio"
402
8
	"crypto/tls"
8
	"crypto/tls"
403
9
	"crypto/x509"
9
	"crypto/x509"
404
10
	"encoding/base64"
405
11
	"encoding/json"
10
	"encoding/json"
406
12
	"io"
11
	"io"
407
13
	"net/http"
12
	"net/http"
408
@@ -22,6 +21,7 @@
409
22
21
410
23
	"launchpad.net/juju-core/state/api/params"
22
	"launchpad.net/juju-core/state/api/params"
411
24
	"launchpad.net/juju-core/testing"
23
	"launchpad.net/juju-core/testing"
412
24
	"launchpad.net/juju-core/utils"
413
25
)
25
)
414
26
26
415
27
type debugLogSuite struct {
27
type debugLogSuite struct {
416
@@ -191,9 +191,7 @@
417
191
}
191
}
418
192
192
419
193
func (s *debugLogSuite) dialWebsocket(c *gc.C, queryParams url.Values) (*websocket.Conn, error) {
193
func (s *debugLogSuite) dialWebsocket(c *gc.C, queryParams url.Values) (*websocket.Conn, error) {
423
194
	header := http.Header{
194
	header := utils.BasicAuthHeader(s.userTag, s.password)
421
195
		"Authorization": {"Basic " + base64.StdEncoding.EncodeToString([]byte(s.userTag+":"+s.password))},
422
196
	}
424
197
	return s.dialWebsocketInternal(c, queryParams, header)
195
	return s.dialWebsocketInternal(c, queryParams, header)
425
198
}
196
}
426
199
197
427
200
198
428
=== modified file 'utils/http.go'
429
--- utils/http.go	2014-03-24 03:24:00 +0000
430
+++ utils/http.go	2014-04-10 09:38:03 +0000
431
@@ -5,6 +5,7 @@
432
5
5
433
6
import (
6
import (
434
7
	"crypto/tls"
7
	"crypto/tls"
435
8
	"encoding/base64"
436
8
	"net/http"
9
	"net/http"
437
9
	"sync"
10
	"sync"
438
10
)
11
)
439
@@ -83,3 +84,18 @@
440
83
	registerFileProtocol(transport)
84
	registerFileProtocol(transport)
441
84
	return transport
85
	return transport
442
85
}
86
}
443
87
444
88
// BasicAuthHeader creates a header that contains just the "Authorization"
445
89
// entry.  The implementation was originally taked from net/http but this is
446
90
// needed externally from the http request object in order to use this with
447
91
// our websockets. See 2 (end of page 4) http://www.ietf.org/rfc/rfc2617.txt
448
92
// "To receive authorization, the client sends the userid and password,
449
93
// separated by a single colon (":") character, within a base64 encoded string
450
94
// in the credentials."
451
95
func BasicAuthHeader(username, password string) http.Header {
452
96
	auth := username + ":" + password
453
97
	encoded := "Basic " + base64.StdEncoding.EncodeToString([]byte(auth))
454
98
	return http.Header{
455
99
		"Authorization": {encoded},
456
100
	}
457
101
}
458
86
102
459
=== modified file 'utils/http_test.go'
460
--- utils/http_test.go	2014-03-24 00:23:19 +0000
461
+++ utils/http_test.go	2014-04-10 09:38:03 +0000
462
@@ -4,10 +4,12 @@
463
4
package utils_test
4
package utils_test
464
5
5
465
6
import (
6
import (
466
7
	"encoding/base64"
467
7
	"fmt"
8
	"fmt"
468
8
	"io/ioutil"
9
	"io/ioutil"
469
9
	"net/http"
10
	"net/http"
470
10
	"net/http/httptest"
11
	"net/http/httptest"
471
12
	"strings"
472
11
13
473
12
	gc "launchpad.net/gocheck"
14
	gc "launchpad.net/gocheck"
474
13
15
475
@@ -79,3 +81,16 @@
476
79
	client2 := utils.GetNonValidatingHTTPClient()
81
	client2 := utils.GetNonValidatingHTTPClient()
477
80
	c.Check(client1, gc.Equals, client2)
82
	c.Check(client1, gc.Equals, client2)
478
81
}
83
}
479
84
480
85
func (s *httpSuite) TestBasicAuthHeader(c *gc.C) {
481
86
	header := utils.BasicAuthHeader("eric", "sekrit")
482
87
	c.Assert(len(header), gc.Equals, 1)
483
88
	auth := header.Get("Authorization")
484
89
	fields := strings.Fields(auth)
485
90
	c.Assert(len(fields), gc.Equals, 2)
486
91
	basic, encoded := fields[0], fields[1]
487
92
	c.Assert(basic, gc.Equals, "Basic")
488
93
	decoded, err := base64.StdEncoding.DecodeString(encoded)
489
94
	c.Assert(err, gc.IsNil)
490
95
	c.Assert(string(decoded), gc.Equals, "eric:sekrit")
491
96
}
Status:	Merged
Approved by:	Tim Penhey on 2014-04-10
Approved revision:	no longer in the source branch.
Merged at revision:	2604
Proposed branch:	lp:~thumper/juju-core/debug-log-api-client
Merge into:	lp:~go-bot/juju-core/trunk
Diff against target:	491 lines (+312/-5) 11 files modified state/api/apiclient.go (+5/-0) state/api/client.go (+131/-0) state/api/client_test.go (+120/-0) state/api/export_test.go (+2/-0) state/api/params/internal.go (+6/-0) state/apiserver/client/client.go (+6/-0) state/apiserver/client/client_test.go (+8/-0) state/apiserver/debuglog.go (+1/-1) state/apiserver/debuglog_test.go (+2/-4) utils/http.go (+16/-0) utils/http_test.go (+15/-0)
To merge this branch:	bzr merge lp:~thumper/juju-core/debug-log-api-client
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Juju Engineering		2014-04-09	Pending
Review via email: mp+214875@code.launchpad.net