debug-log: added new debug log api and command

cmd/juju/debuglog.go

-// Copyright 2013 Canonical Ltd.
+// Copyright 2013, 2014 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package main
 
 import (
         "fmt"
+        "io"
+        "os"
+        "os/exec"
         "strconv"
 
         "launchpad.net/gnuflag"
 
         "launchpad.net/juju-core/cmd"
+        "launchpad.net/juju-core/environs"
+        "launchpad.net/juju-core/environs/configstore"
+        "launchpad.net/juju-core/juju"
+        "launchpad.net/juju-core/juju/osenv"
+        "launchpad.net/juju-core/provider"
 )
 
 type DebugLogCommand struct {
-        cmd.CommandBase
-        // The debug log command simply invokes juju ssh with the required arguments.
-        sshCmd cmd.Command
-        lines  linesValue
+        cmd.EnvCommandBase
+
+        lines  int
+        filter string
 }
 
 // defaultLineCount is the default number of lines to
 // display, from the end of the consolidated log.
 const defaultLineCount = 10
 
-// linesValue implements gnuflag.Value, and represents
-// a -n/--lines flag value compatible with "tail".
-//
-// A negative value (-K) corresponds to --lines=K,
-// i.e. the last K lines; a positive value (+K)
-// corresponds to --lines=+K, i.e. from line K onwards.
-type linesValue int
-
-func (v *linesValue) String() string {
-        if *v > 0 {
-                return fmt.Sprintf("+%d", *v)
-        }
-        return fmt.Sprint(-*v)
-}
-
-func (v *linesValue) Set(value string) error {
-        if len(value) > 0 {
-                sign := -1
-                if value[0] == '+' {
-                        value = value[1:]
-                        sign = 1
-                }
-                n, err := strconv.ParseInt(value, 10, 0)
-                if err == nil && n > 0 {
-                        *v = linesValue(sign * int(n))
-                        return nil
-                }
-                // err is quite verbose, and doesn't convey
-                // any additional useful information.
-        }
-        return fmt.Errorf("invalid number of lines")
-}
-
 const debuglogDoc = `
-Launch an ssh shell on the state server machine and tail the consolidated log file.
-The consolidated log file contains log messages from all nodes in the environment.
+Stream the consolidated debug log file. This file contains the log messages
+from all nodes in the environment.
 `
 
 func (c *DebugLogCommand) Info() *cmd.Info {
         return &cmd.Info{
                 Name:    "debug-log",
                 Purpose: "display the consolidated log file",
                 Doc:     debuglogDoc,
         }
 }
 
 func (c *DebugLogCommand) SetFlags(f *gnuflag.FlagSet) {
-        c.sshCmd.SetFlags(f)
-
-        c.lines = -defaultLineCount
-        f.Var(&c.lines, "n", "output the last K lines; or use -n +K to output lines starting with the Kth")
-        f.Var(&c.lines, "lines", "")
-}
-
-func (c *DebugLogCommand) AllowInterspersedFlags() bool {
-        return true
+        f.IntVar(&c.lines, "n", defaultLineCount, "output the last K lines; or use -n +K to output lines starting with the Kth")
+        f.IntVar(&c.lines, "lines", defaultLineCount, "")
+        f.StringVar(&c.filter, "f", "", "filter the output with a regular expression")
+        f.StringVar(&c.filter, "filter", "", "")
 }
 
 func (c *DebugLogCommand) Init(args []string) error {
-        tailcmd := fmt.Sprintf("tail -n %s -f /var/log/juju/all-machines.log", &c.lines)
-        args = append([]string{"0"}, args...)
-        args = append(args, tailcmd)
-        return c.sshCmd.Init(args)
+        return nil
 }
 
-// Run uses "juju ssh" to log into the state server node
-// and tails the consolidated log file which captures log
-// messages from all nodes.
-func (c *DebugLogCommand) Run(ctx *cmd.Context) error {
-        return c.sshCmd.Run(ctx)
+// Run retrieves the debug log via the API.
+func (c *DebugLogCommand) Run(ctx *cmd.Context) (err error) {
+        client, err := juju.NewAPIClientFromName(c.EnvName)
+        if err != nil {
+                return err
+        }
+        defer client.Close()
+
+        debugLog, err := client.WatchDebugLog(c.lines, c.filter)
+        if err != nil {
+                logger.Infof("WatchDebugLog not supported by the API server, " +
+                        "falling back to 1.16 compatibility mode using ssh")
+                return c.watchDebugLog1dot16(ctx)
+        }
+        defer debugLog.Close()
+
+        _, err = io.Copy(os.Stdout, debugLog)
+        return err
 }
+
+// watchDebugLog1dot16 runs in case of an older API server and uses ssh
+// but with server-side grep.
+func (c *DebugLogCommand) watchDebugLog1dot16(ctx *cmd.Context) error {
+        name, local, err := c.currentEnvironment()
+        if err != nil {
+                return err
+        }
+        // Work depending on the provider.
+        if local {
+                // Local provider tails local log file.
+                logLocation := fmt.Sprintf("%s/%s/log/all-machines.log", osenv.JujuHomeDir(), name)
+                tailCmd := exec.Command("tail", "-n", strconv.Itoa(c.lines), "-f", logLocation)
+                grepCmd := exec.Command("grep", c.filter)

[rog, 2014/02/10 16:24:50]

I think you probably want grep -E here for compatibility
with the regexps accepted by the juju version.

+                r, w := io.Pipe()
+
+                tailCmd.Stdout = w
+                grepCmd.Stdin = r
+                grepCmd.Stdout = os.Stdout
+                grepCmd.Stderr = os.Stderr
+
+                err := tailCmd.Start()
+                if err != nil {
+                        return err
+                }
+                err = grepCmd.Start()
+                if err != nil {
+                        return err
+                }
+                return grepCmd.Wait()
+        }
+        // Any other provider uses ssh with tail.
+        logLocation := "/var/log/juju/all-machines.log"
+        sshCmd := &SSHCommand{}
+        tailGrepCmd := fmt.Sprintf("tail -n %d -f %s|grep %s", c.lines, logLocation, c.filter)
+        args := []string{"0", tailGrepCmd}
+        err = sshCmd.Init(args)
+        if err != nil {
+                return err
+        }
+        return sshCmd.Run(ctx)
+}
+
+// currentEnvironment returns the name of the environment and if it is local.
+func (c *DebugLogCommand) currentEnvironment() (string, bool, error) {
+        store, err := configstore.Default()
+        if err != nil {
+                return "", false, fmt.Errorf("cannot open environment info storage: %v", err)
+        }
+        environ, err := environs.NewFromName(c.EnvironName(), store)
+        if err != nil {
+                return "", false, err
+        }
+        local := environ.Config().Type() == provider.Local
+        return environ.Name(), local, nil
+}