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/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 {
@@ skipping 428 matching lines @@
                 var err error
                 if archive, err = os.Open(ch.Path); err != nil {
                         return nil, fmt.Errorf("cannot read charm archive: %v", err)
                 }
                 defer archive.Close()
         default:
                 return nil, fmt.Errorf("unknown charm type %T", ch)
         }
 
         // Prepare the upload request.
-        url := fmt.Sprintf("%s/charms?series=%s", c.st.serverRoot, curl.Series)
+        url := fmt.Sprintf("https://%s/charms?series=%s", c.st.serverHostPort, curl.Series)
         req, err := http.NewRequest("POST", url, archive)
         if err != nil {
                 return nil, fmt.Errorf("cannot create upload request: %v", err)
         }
         req.SetBasicAuth(c.st.tag, c.st.password)
         req.Header.Set("Content-Type", "application/zip")
 
         // Send the request.
 
         // BUG(dimitern) 2013-12-17 bug #1261780
@@ skipping 34 matching lines @@
 }
 
 // AddCharm adds the given charm URL (which must include revision) to
 // the environment, if it does not exist yet. Local charms are not
 // supported, only charm store URLs. See also AddLocalCharm() in the
 // client-side API.
 func (c *Client) AddCharm(curl *charm.URL) error {
         args := params.CharmURL{URL: curl.String()}
         return c.st.Call("Client", "", "AddCharm", args, nil)
 }
+
+// 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{
+                "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 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.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 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))
+}