debug-log: added new debug log api and command

state/api/client.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package api
 
 import (
         "encoding/base64"
         "encoding/json"
         "fmt"
         "io/ioutil"
         "net/http"
         "net/url"
         "os"
         "time"
 
         "code.google.com/p/go.net/websocket"
 
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/constraints"
         "launchpad.net/juju-core/instance"
-        "launchpad.net/juju-core/juju/osenv"
         "launchpad.net/juju-core/state/api/params"
         "launchpad.net/juju-core/utils"
         "launchpad.net/juju-core/version"
 )
 
 // Client represents the client-accessible part of the state.
 type Client struct {
         st *State
 }
 
@@ skipping 489 matching lines @@
 }
 
 // WatchDebugLog returns a ClientDebugLog reading the debug log message.
 // The filter allows to grep wanted lines out of the output, e.g.
 // machines or units. The watching is started the given number of
 // matching lines back in history.
 func (c *Client) WatchDebugLog(lines int, filter string) (*ClientDebugLog, error) {
         cfg := c.st.websocketConfig
         // Prepare URL.
         attrs := url.Values{
-                "juju-home": {osenv.JujuHomeDir()},

[rog, 2014/01/31 15:59:11]

This doesn't seem quite right. Why are we sending a local directory name to the
server? For the local provider, surely the server side can find out where the
log file is kept?

[mue, 2014/01/31 17:32:37]

Sure there may be a way to change environ. But the local machine 0 is running as
root and doesn't know about the JUJU_HOME of the user who has started it. 

-                "lines":     {fmt.Sprintf("%d", lines)},
-                "filter":    {filter},
+                "lines":  {fmt.Sprintf("%d", lines)},
+                "filter": {filter},
         }
         cfg.Location = &url.URL{
                 Scheme:   "wss",
                 Host:     c.st.serverHostPort,
                 Path:     "/log",
                 RawQuery: attrs.Encode(),
         }
         cfg.Header = make(http.Header)
         setBasicAuth(cfg.Header, c.st.tag, c.st.password)
 
         wsConn, err := websocket.DialConfig(&cfg)
         if err != nil {
                 return nil, err
         }
         return &ClientDebugLog{wsConn}, nil
 }
 
 // ClientDebugLog represents a stream of debug log messages.
 type ClientDebugLog struct {
         wsConn *websocket.Conn
 }
 
 // Close closes the log.
 func (c *ClientDebugLog) Close() error {
         return c.wsConn.Close()
 }
 
-// SetFilter sets the entity tags that apply to the filter.

[dimitern, 2014/01/31 17:02:29]

s/the entity tags that apply to the filter/the filter to apply./

[mue, 2014/01/31 17:32:37]

Will change.

[mue, 2014/02/02 20:11:54]

Done.

-// This setting will not take place immediately - messages
+// SetFilter sets the filter regular expression. This
+// setting will not take place immediately - messages
 // already in the pipeline will still be received.
 func (c *ClientDebugLog) SetFilter(filter string) error {
-        req := params.EntityLogRequest{Filter: filter}
+        req := params.DebugLogRequest{Filter: filter}
         if err := websocket.JSON.Send(c.wsConn, &req); err != nil {
                 return err
         }
         return nil
 }
 
 // Read implements io.Reader.Read.
 func (c *ClientDebugLog) Read(buf []byte) (int, error) {
         return c.wsConn.Read(buf)
 }
 
-// setBasicAuth sets the basic authentication of the passed header.

[dimitern, 2014/01/31 17:02:29]

// setBasicAuth creates an Authorization header for HTTP Basic Authentication,
using the given username and password ?

[mue, 2014/01/31 17:32:37]

Please discuss with Roger. It's based on his draft.

[dimitern, 2014/01/31 17:57:09]

I'm just suggesting a more appropriate description, based on the one found in
http.SetBasicAuth. I'm not suggesting to change the code.

[mue, 2014/02/02 20:11:54]

Done.

+// setBasicAuth creates an Authorization header for HTTP Basic
+// Authentication, using the given username and password.
 func setBasicAuth(h http.Header, username, password string) {
         h.Set("Authorization", "Basic "+basicAuth(username, password))
 }
 
 // basicAuth is copied from net/http.
 // See 2 (end of page 4) http://www.ietf.org/rfc/rfc2617.txt
 // "To receive authorization, the client sends the userid and password,
 // separated by a single colon (":") character, within a base64
 // encoded string in the credentials."
 // It is not meant to be urlencoded.
 func basicAuth(username, password string) string {
         auth := username + ":" + password
         return base64.StdEncoding.EncodeToString([]byte(auth))
 }