Implement docker events with standalone client lib.

Signed-off-by: David Calavera <david.calavera@gmail.com>

api/client/events.go

@@ -1,14 +1,12 @@
 package client
 
 import (
-	"net/url"
+	"github.com/docker/docker/api/client/lib"
-	"time"
-
 	Cli "github.com/docker/docker/cli"
 	"github.com/docker/docker/opts"
+	"github.com/docker/docker/pkg/jsonmessage"
 	flag "github.com/docker/docker/pkg/mflag"
 	"github.com/docker/docker/pkg/parsers/filters"
-	"github.com/docker/docker/pkg/timeutils"
 )
 
 // CmdEvents prints a live stream of real time events from the server.
@@ -24,10 +22,7 @@ func (cli *DockerCli) CmdEvents(args ...string) error {
 
 	cmd.ParseFlags(args, true)
 
-	var (
+	eventFilterArgs := filters.NewArgs()
-		v               = url.Values{}
-		eventFilterArgs = filters.NewArgs()
-	)
 
 	// Consolidate all filter flags, and sanity check them early.
 	// They'll get process in the daemon/server.
@@ -38,34 +33,18 @@ func (cli *DockerCli) CmdEvents(args ...string) error {
 			return err
 		}
 	}
-	ref := time.Now()
+
-	if *since != "" {
+	options := lib.EventsOptions{
-		ts, err := timeutils.GetTimestamp(*since, ref)
+		Since:   *since,
-		if err != nil {
+		Until:   *until,
-			return err
+		Filters: eventFilterArgs,
-		}
-		v.Set("since", ts)
 	}
-	if *until != "" {
+
-		ts, err := timeutils.GetTimestamp(*until, ref)
+	responseBody, err := cli.client.Events(options)
-		if err != nil {
+	if err != nil {
-			return err
-		}
-		v.Set("until", ts)
-	}
-	if eventFilterArgs.Len() > 0 {
-		filterJSON, err := filters.ToParam(eventFilterArgs)
-		if err != nil {
-			return err
-		}
-		v.Set("filters", filterJSON)
-	}
-	sopts := &streamOpts{
-		rawTerminal: true,
-		out:         cli.out,
-	}
-	if _, err := cli.stream("GET", "/events?"+v.Encode(), sopts); err != nil {
 		return err
 	}
-	return nil
+	defer responseBody.Close()
+
+	return jsonmessage.DisplayJSONMessagesStream(responseBody, cli.out, cli.outFd, cli.isTerminalOut)
 }

api/client/lib/events.go

@@ -0,0 +1,52 @@
+package lib
+
+import (
+	"io"
+	"net/url"
+	"time"
+
+	"github.com/docker/docker/pkg/parsers/filters"
+	"github.com/docker/docker/pkg/timeutils"
+)
+
+// EventsOptions hold parameters to filter events with.
+type EventsOptions struct {
+	Since   string
+	Until   string
+	Filters filters.Args
+}
+
+// Events returns a stream of events in the daemon in a ReadCloser.
+// It's up to the caller to close the stream.
+func (cli *Client) Events(options EventsOptions) (io.ReadCloser, error) {
+	var query url.Values
+	ref := time.Now()
+
+	if options.Since != "" {
+		ts, err := timeutils.GetTimestamp(options.Since, ref)
+		if err != nil {
+			return nil, err
+		}
+		query.Set("since", ts)
+	}
+	if options.Until != "" {
+		ts, err := timeutils.GetTimestamp(options.Until, ref)
+		if err != nil {
+			return nil, err
+		}
+		query.Set("until", ts)
+	}
+	if options.Filters.Len() > 0 {
+		filterJSON, err := filters.ToParam(options.Filters)
+		if err != nil {
+			return nil, err
+		}
+		query.Set("filters", filterJSON)
+	}
+
+	serverResponse, err := cli.GET("/events", query, nil)
+	if err != nil {
+		return nil, err
+	}
+	return serverResponse.body, nil
+}