@@ -36,14 +36,14 @@ func (sr *swarmRouter) initRoutes() {

 		router.NewPostRoute("/services/create", sr.createService),

 		router.NewPostRoute("/services/{id}/update", sr.updateService),

 		router.NewDeleteRoute("/services/{id}", sr.removeService),

-		router.Experimental(router.Cancellable(router.NewGetRoute("/services/{id}/logs", sr.getServiceLogs))),

+		router.Cancellable(router.NewGetRoute("/services/{id}/logs", sr.getServiceLogs)),

 		router.NewGetRoute("/nodes", sr.getNodes),

 		router.NewGetRoute("/nodes/{id}", sr.getNode),

 		router.NewDeleteRoute("/nodes/{id}", sr.removeNode),

 		router.NewPostRoute("/nodes/{id}/update", sr.updateNode),

 		router.NewGetRoute("/tasks", sr.getTasks),

 		router.NewGetRoute("/tasks/{id}", sr.getTask),

-		router.Experimental(router.Cancellable(router.NewGetRoute("/tasks/{id}/logs", sr.getTaskLogs))),

+		router.Cancellable(router.NewGetRoute("/tasks/{id}/logs", sr.getTaskLogs)),

 		router.NewGetRoute("/secrets", sr.getSecrets),

 		router.NewPostRoute("/secrets/create", sr.createSecret),

 		router.NewDeleteRoute("/secrets/{id}", sr.removeSecret),

@@ -7729,12 +7729,12 @@ paths:

           schema:

             type: "string"

         404:

-          description: "no such container"

+          description: "no such service"

           schema:

             $ref: "#/definitions/ErrorResponse"

           examples:

             application/json:

-              message: "No such container: c2ada9df5af8"

+              message: "No such service: c2ada9df5af8"

         500:

           description: "server error"

           schema:

@@ -7747,11 +7747,11 @@ paths:

         - name: "id"

           in: "path"

           required: true

-          description: "ID or name of the container"

+          description: "ID or name of the service"

           type: "string"

         - name: "details"

           in: "query"

-          description: "Show extra details provided to logs."

+          description: "Show service context and extra details provided to logs."

           type: "boolean"

           default: false

         - name: "follow"

@@ -8008,7 +8008,7 @@ paths:

           type: "string"

         - name: "details"

           in: "query"

-          description: "Show extra details provided to logs."

+          description: "Show task context and extra details provided to logs."

           type: "boolean"

           default: false

         - name: "follow"

@@ -42,20 +42,22 @@ func newLogsCommand(dockerCli *command.DockerCli) *cobra.Command {

 	var opts logsOptions

 	cmd := &cobra.Command{

-		Use:   "logs [OPTIONS] SERVICE",

-		Short: "Fetch the logs of a service",

+		Use:   "logs [OPTIONS] SERVICE|TASK",

+		Short: "Fetch the logs of a service or task",

 		Args:  cli.ExactArgs(1),

 		RunE: func(cmd *cobra.Command, args []string) error {

 			opts.target = args[0]

 			return runLogs(dockerCli, &opts)

 		},

-		Tags: map[string]string{"experimental": ""},

+		Tags: map[string]string{"version": "1.29"},

 	}

 	flags := cmd.Flags()

+	// options specific to service logs

 	flags.BoolVar(&opts.noResolve, "no-resolve", false, "Do not map IDs to Names in output")

 	flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Do not truncate output")

 	flags.BoolVar(&opts.noTaskIDs, "no-task-ids", false, "Do not include task IDs in output")

+	// options identical to container logs

 	flags.BoolVarP(&opts.follow, "follow", "f", false, "Follow log output")

 	flags.StringVar(&opts.since, "since", "", "Show logs since timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)")

 	flags.BoolVarP(&opts.timestamps, "timestamps", "t", false, "Show timestamps")

@@ -94,6 +96,8 @@ func runLogs(dockerCli *command.DockerCli, opts *logsOptions) error {

 		tty = task.Spec.ContainerSpec.TTY

 		// TODO(dperny) hot fix until we get a nice details system squared away,

 		// ignores details (including task context) if we have a TTY log

+		// if we don't do this, we'll vomit the huge context verbatim into the

+		// TTY log lines and that's Undesirable.

 		if tty {

 			options.Details = false

 		}

@@ -1,8 +1,7 @@

 ---

-title: "service logs (experimental)"

+title: "service logs"

 description: "The service logs command description and usage"

-keywords: "service, logs"

-advisory: "experimental"

+keywords: "service, task, logs"

 ---

 <!-- This file is maintained within the docker/docker Github

@@ -17,14 +16,16 @@ advisory: "experimental"

 # service logs

 ```Markdown

-Usage:  docker service logs [OPTIONS] SERVICE

+Usage:  docker service logs [OPTIONS] SERVICE|TASK

-Fetch the logs of a service

+Fetch the logs of a service or task

 Options:

-      --details        Show extra details provided to logs

   -f, --follow         Follow log output

       --help           Print usage

+      --no-resolve     Do not map IDs to Names in output

+      --no-task-ids    Do not include task IDs in output

+      --no-trunc        Do not truncate output

       --since string   Show logs since timestamp

       --tail string    Number of lines to show from the end of the logs (default "all")

   -t, --timestamps     Show timestamps

@@ -34,6 +35,11 @@ Options:

 The `docker service logs` command batch-retrieves logs present at the time of execution.

+The `docker service logs` command can be used with either the name or ID of a

+service, or with the ID of a task. If a service is passed, it will display logs

+for all of the containers in that service. If a task is passed, it will only

+display logs from that particular task.

+

 > **Note**: This command is only functional for services that are started with

 > the `json-file` or `journald` logging driver.

@@ -40,7 +40,6 @@ Metrics (Prometheus) output for basic container, image, and daemon operations.

  * The top-level [docker deploy](../docs/reference/commandline/deploy.md) command. The

    `docker stack deploy` command is **not** experimental.

- * [`docker service logs` command](../docs/reference/commandline/service_logs.md)

  * [`--squash` option to `docker build` command](../docs/reference/commandline/build.md##squash-an-images-layers---squash-experimental-only)

  * [External graphdriver plugins](../docs/extend/plugins_graphdriver.md)

  * [Ipvlan Network Drivers](vlan-networks.md)

deleted file mode 100644

@@ -1,296 +0,0 @@

-// +build !windows

-

-package main

-

-import (

-	"bufio"

-	"fmt"

-	"io"

-	"os/exec"

-	"strings"

-	"time"

-

-	"github.com/docker/docker/integration-cli/checker"

-	"github.com/docker/docker/integration-cli/daemon"

-	icmd "github.com/docker/docker/pkg/testutil/cmd"

-	"github.com/go-check/check"

-)

-

-type logMessage struct {

-	err  error

-	data []byte

-}

-

-func (s *DockerSwarmSuite) TestServiceLogs(c *check.C) {

-	testRequires(c, ExperimentalDaemon)

-

-	d := s.AddDaemon(c, true, true)

-

-	// we have multiple services here for detecting the goroutine issue #28915

-	services := map[string]string{

-		"TestServiceLogs1": "hello1",

-		"TestServiceLogs2": "hello2",

-	}

-

-	for name, message := range services {

-		out, err := d.Cmd("service", "create", "--name", name, "busybox",

-			"sh", "-c", fmt.Sprintf("echo %s; tail -f /dev/null", message))

-		c.Assert(err, checker.IsNil)

-		c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")

-	}

-

-	// make sure task has been deployed.

-	waitAndAssert(c, defaultReconciliationTimeout,

-		d.CheckRunningTaskImages, checker.DeepEquals,

-		map[string]int{"busybox": len(services)})

-

-	for name, message := range services {

-		out, err := d.Cmd("service", "logs", name)

-		c.Assert(err, checker.IsNil)

-		c.Logf("log for %q: %q", name, out)

-		c.Assert(out, checker.Contains, message)

-	}

-}

-

-// countLogLines returns a closure that can be used with waitAndAssert to

-// verify that a minimum number of expected container log messages have been

-// output.

-func countLogLines(d *daemon.Swarm, name string) func(*check.C) (interface{}, check.CommentInterface) {

-	return func(c *check.C) (interface{}, check.CommentInterface) {

-		result := icmd.RunCmd(d.Command("service", "logs", "-t", name))

-		result.Assert(c, icmd.Expected{})

-		lines := strings.Split(strings.TrimSpace(result.Stdout()), "\n")

-		return len(lines), check.Commentf("output, %q", string(result.Stdout()))

-	}

-}

-

-func (s *DockerSwarmSuite) TestServiceLogsCompleteness(c *check.C) {

-	testRequires(c, ExperimentalDaemon)

-	d := s.AddDaemon(c, true, true)

-

-	name := "TestServiceLogsCompleteness"

-

-	// make a service that prints 6 lines

-	out, err := d.Cmd("service", "create", "--name", name, "busybox", "sh", "-c", "for line in $(seq 0 5); do echo log test $line; done; sleep 100000")

-	c.Assert(err, checker.IsNil)

-	c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")

-

-	// make sure task has been deployed.

-	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)

-	// and make sure we have all the log lines

-	waitAndAssert(c, defaultReconciliationTimeout, countLogLines(d, name), checker.Equals, 6)

-

-	out, err = d.Cmd("service", "logs", name)

-	c.Assert(err, checker.IsNil)

-	lines := strings.Split(strings.TrimSpace(out), "\n")

-

-	// i have heard anecdotal reports that logs may come back from the engine

-	// mis-ordered. if this tests fails, consider the possibility that that

-	// might be occurring

-	for i, line := range lines {

-		c.Assert(line, checker.Contains, fmt.Sprintf("log test %v", i))

-	}

-}

-

-func (s *DockerSwarmSuite) TestServiceLogsTail(c *check.C) {

-	testRequires(c, ExperimentalDaemon)

-	d := s.AddDaemon(c, true, true)

-

-	name := "TestServiceLogsTail"

-

-	// make a service that prints 6 lines

-	out, err := d.Cmd("service", "create", "--name", name, "busybox", "sh", "-c", "for line in $(seq 1 6); do echo log test $line; done; sleep 100000")

-	c.Assert(err, checker.IsNil)

-	c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")

-

-	// make sure task has been deployed.

-	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)

-	waitAndAssert(c, defaultReconciliationTimeout, countLogLines(d, name), checker.Equals, 6)

-

-	out, err = d.Cmd("service", "logs", "--tail=2", name)

-	c.Assert(err, checker.IsNil)

-	lines := strings.Split(strings.TrimSpace(out), "\n")

-

-	for i, line := range lines {

-		// doing i+5 is hacky but not too fragile, it's good enough. if it flakes something else is wrong

-		c.Assert(line, checker.Contains, fmt.Sprintf("log test %v", i+5))

-	}

-}

-

-func (s *DockerSwarmSuite) TestServiceLogsSince(c *check.C) {

-	// See DockerSuite.TestLogsSince, which is where this comes from

-	testRequires(c, ExperimentalDaemon)

-	d := s.AddDaemon(c, true, true)

-

-	name := "TestServiceLogsSince"

-

-	out, err := d.Cmd("service", "create", "--name", name, "busybox", "sh", "-c", "for i in $(seq 1 3); do sleep .1; echo log$i; done; sleep 10000000")

-	c.Assert(err, checker.IsNil)

-	c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")

-	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)

-	// wait a sec for the logs to come in

-	waitAndAssert(c, defaultReconciliationTimeout, countLogLines(d, name), checker.Equals, 3)

-

-	out, err = d.Cmd("service", "logs", "-t", name)

-	c.Assert(err, checker.IsNil)

-

-	log2Line := strings.Split(strings.Split(out, "\n")[1], " ")

-	t, err := time.Parse(time.RFC3339Nano, log2Line[0]) // timestamp log2 is written

-	c.Assert(err, checker.IsNil)

-	u := t.Add(50 * time.Millisecond) // add .05s so log1 & log2 don't show up

-	since := u.Format(time.RFC3339Nano)

-

-	out, err = d.Cmd("service", "logs", "-t", fmt.Sprintf("--since=%v", since), name)

-	c.Assert(err, checker.IsNil)

-

-	unexpected := []string{"log1", "log2"}

-	expected := []string{"log3"}

-	for _, v := range unexpected {

-		c.Assert(out, checker.Not(checker.Contains), v, check.Commentf("unexpected log message returned, since=%v", u))

-	}

-	for _, v := range expected {

-		c.Assert(out, checker.Contains, v, check.Commentf("expected log message %v, was not present, since=%v", u))

-	}

-}

-

-func (s *DockerSwarmSuite) TestServiceLogsFollow(c *check.C) {

-	testRequires(c, ExperimentalDaemon)

-

-	d := s.AddDaemon(c, true, true)

-

-	name := "TestServiceLogsFollow"

-

-	out, err := d.Cmd("service", "create", "--name", name, "busybox", "sh", "-c", "while true; do echo log test; sleep 0.1; done")

-	c.Assert(err, checker.IsNil)

-	c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")

-

-	// make sure task has been deployed.

-	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)

-

-	args := []string{"service", "logs", "-f", name}

-	cmd := exec.Command(dockerBinary, d.PrependHostArg(args)...)

-	r, w := io.Pipe()

-	cmd.Stdout = w

-	cmd.Stderr = w

-	c.Assert(cmd.Start(), checker.IsNil)

-

-	// Make sure pipe is written to

-	ch := make(chan *logMessage)

-	done := make(chan struct{})

-	go func() {

-		reader := bufio.NewReader(r)

-		for {

-			msg := &logMessage{}

-			msg.data, _, msg.err = reader.ReadLine()

-			select {

-			case ch <- msg:

-			case <-done:

-				return

-			}

-		}

-	}()

-

-	for i := 0; i < 3; i++ {

-		msg := <-ch

-		c.Assert(msg.err, checker.IsNil)

-		c.Assert(string(msg.data), checker.Contains, "log test")

-	}

-	close(done)

-

-	c.Assert(cmd.Process.Kill(), checker.IsNil)

-}

-

-func (s *DockerSwarmSuite) TestServiceLogsTaskLogs(c *check.C) {

-	testRequires(c, ExperimentalDaemon)

-

-	d := s.AddDaemon(c, true, true)

-

-	name := "TestServicelogsTaskLogs"

-	replicas := 2

-

-	result := icmd.RunCmd(d.Command(

-		// create a service with the name

-		"service", "create", "--name", name,

-		// which has some number of replicas

-		fmt.Sprintf("--replicas=%v", replicas),

-		// which has this the task id as an environment variable templated in

-		"--env", "TASK={{.Task.ID}}",

-		// and runs this command to print exaclty 6 logs lines

-		"busybox", "sh", "-c", "for line in $(seq 0 5); do echo $TASK log test $line; done; sleep 100000",

-	))

-	result.Assert(c, icmd.Expected{})

-	// ^^ verify that we get no error

-	// then verify that we have an id in stdout

-	id := strings.TrimSpace(result.Stdout())

-	c.Assert(id, checker.Not(checker.Equals), "")

-	// so, right here, we're basically inspecting by id and returning only

-	// the ID. if they don't match, the service doesn't exist.

-	result = icmd.RunCmd(d.Command("service", "inspect", "--format=\"{{.ID}}\"", id))

-	result.Assert(c, icmd.Expected{Out: id})

-

-	// make sure task has been deployed.

-	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, replicas)

-	waitAndAssert(c, defaultReconciliationTimeout, countLogLines(d, name), checker.Equals, 6*replicas)

-

-	// get the task ids

-	result = icmd.RunCmd(d.Command("service", "ps", "-q", name))

-	result.Assert(c, icmd.Expected{})

-	// make sure we have two tasks

-	taskIDs := strings.Split(strings.TrimSpace(result.Stdout()), "\n")

-	c.Assert(taskIDs, checker.HasLen, replicas)

-

-	for _, taskID := range taskIDs {

-		c.Logf("checking task %v", taskID)

-		result := icmd.RunCmd(d.Command("service", "logs", taskID))

-		result.Assert(c, icmd.Expected{})

-		lines := strings.Split(strings.TrimSpace(result.Stdout()), "\n")

-

-		c.Logf("checking messages for %v", taskID)

-		for i, line := range lines {

-			// make sure the message is in order

-			c.Assert(line, checker.Contains, fmt.Sprintf("log test %v", i))

-			// make sure it contains the task id

-			c.Assert(line, checker.Contains, taskID)

-		}

-	}

-}

-

-func (s *DockerSwarmSuite) TestServiceLogsTTY(c *check.C) {

-	testRequires(c, ExperimentalDaemon)

-

-	d := s.AddDaemon(c, true, true)

-

-	name := "TestServiceLogsTTY"

-

-	result := icmd.RunCmd(d.Command(

-		// create a service

-		"service", "create",

-		// name it $name

-		"--name", name,

-		// use a TTY

-		"-t",

-		// busybox image, shell string

-		"busybox", "sh", "-c",

-		// echo to stdout and stderr

-		"echo out; (echo err 1>&2); sleep 10000",

-	))

-

-	result.Assert(c, icmd.Expected{})

-	id := strings.TrimSpace(result.Stdout())

-	c.Assert(id, checker.Not(checker.Equals), "")

-	// so, right here, we're basically inspecting by id and returning only

-	// the ID. if they don't match, the service doesn't exist.

-	result = icmd.RunCmd(d.Command("service", "inspect", "--format=\"{{.ID}}\"", id))

-	result.Assert(c, icmd.Expected{Out: id})

-

-	// make sure task has been deployed.

-	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)

-	// and make sure we have all the log lines

-	waitAndAssert(c, defaultReconciliationTimeout, countLogLines(d, name), checker.Equals, 2)

-

-	cmd := d.Command("service", "logs", name)

-	result = icmd.RunCmd(cmd)

-	// for some reason there is carriage return in the output. i think this is

-	// just expected.

-	c.Assert(result, icmd.Matches, icmd.Expected{Out: "out\r\nerr\r\n"})

-}

new file mode 100644

@@ -0,0 +1,285 @@

+// +build !windows

+

+package main

+

+import (

+	"bufio"

+	"fmt"

+	"io"

+	"os/exec"

+	"strings"

+	"time"

+

+	"github.com/docker/docker/integration-cli/checker"

+	"github.com/docker/docker/integration-cli/daemon"

+	icmd "github.com/docker/docker/pkg/testutil/cmd"

+	"github.com/go-check/check"

+)

+

+type logMessage struct {

+	err  error

+	data []byte

+}

+

+func (s *DockerSwarmSuite) TestServiceLogs(c *check.C) {

+	d := s.AddDaemon(c, true, true)

+

+	// we have multiple services here for detecting the goroutine issue #28915

+	services := map[string]string{

+		"TestServiceLogs1": "hello1",

+		"TestServiceLogs2": "hello2",

+	}

+

+	for name, message := range services {

+		out, err := d.Cmd("service", "create", "--name", name, "busybox",

+			"sh", "-c", fmt.Sprintf("echo %s; tail -f /dev/null", message))

+		c.Assert(err, checker.IsNil)

+		c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")

+	}

+

+	// make sure task has been deployed.

+	waitAndAssert(c, defaultReconciliationTimeout,

+		d.CheckRunningTaskImages, checker.DeepEquals,

+		map[string]int{"busybox": len(services)})

+

+	for name, message := range services {

+		out, err := d.Cmd("service", "logs", name)

+		c.Assert(err, checker.IsNil)

+		c.Logf("log for %q: %q", name, out)

+		c.Assert(out, checker.Contains, message)

+	}

+}

+

+// countLogLines returns a closure that can be used with waitAndAssert to

+// verify that a minimum number of expected container log messages have been

+// output.

+func countLogLines(d *daemon.Swarm, name string) func(*check.C) (interface{}, check.CommentInterface) {

+	return func(c *check.C) (interface{}, check.CommentInterface) {

+		result := icmd.RunCmd(d.Command("service", "logs", "-t", name))

+		result.Assert(c, icmd.Expected{})

+		lines := strings.Split(strings.TrimSpace(result.Stdout()), "\n")

+		return len(lines), check.Commentf("output, %q", string(result.Stdout()))

+	}

+}

+

+func (s *DockerSwarmSuite) TestServiceLogsCompleteness(c *check.C) {

+	d := s.AddDaemon(c, true, true)

+

+	name := "TestServiceLogsCompleteness"

+

+	// make a service that prints 6 lines

+	out, err := d.Cmd("service", "create", "--name", name, "busybox", "sh", "-c", "for line in $(seq 0 5); do echo log test $line; done; sleep 100000")

+	c.Assert(err, checker.IsNil)

+	c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")

+

+	// make sure task has been deployed.

+	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)

+	// and make sure we have all the log lines

+	waitAndAssert(c, defaultReconciliationTimeout, countLogLines(d, name), checker.Equals, 6)

+

+	out, err = d.Cmd("service", "logs", name)

+	c.Assert(err, checker.IsNil)

+	lines := strings.Split(strings.TrimSpace(out), "\n")

+

+	// i have heard anecdotal reports that logs may come back from the engine

+	// mis-ordered. if this tests fails, consider the possibility that that

+	// might be occurring

+	for i, line := range lines {

+		c.Assert(line, checker.Contains, fmt.Sprintf("log test %v", i))

+	}

+}

+

+func (s *DockerSwarmSuite) TestServiceLogsTail(c *check.C) {

+	d := s.AddDaemon(c, true, true)

+

+	name := "TestServiceLogsTail"

+

+	// make a service that prints 6 lines

+	out, err := d.Cmd("service", "create", "--name", name, "busybox", "sh", "-c", "for line in $(seq 1 6); do echo log test $line; done; sleep 100000")

+	c.Assert(err, checker.IsNil)

+	c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")

+

+	// make sure task has been deployed.

+	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)

+	waitAndAssert(c, defaultReconciliationTimeout, countLogLines(d, name), checker.Equals, 6)

+

+	out, err = d.Cmd("service", "logs", "--tail=2", name)

+	c.Assert(err, checker.IsNil)

+	lines := strings.Split(strings.TrimSpace(out), "\n")

+

+	for i, line := range lines {

+		// doing i+5 is hacky but not too fragile, it's good enough. if it flakes something else is wrong

+		c.Assert(line, checker.Contains, fmt.Sprintf("log test %v", i+5))

+	}

+}

+

+func (s *DockerSwarmSuite) TestServiceLogsSince(c *check.C) {

+	// See DockerSuite.TestLogsSince, which is where this comes from

+	d := s.AddDaemon(c, true, true)

+

+	name := "TestServiceLogsSince"

+

+	out, err := d.Cmd("service", "create", "--name", name, "busybox", "sh", "-c", "for i in $(seq 1 3); do sleep .1; echo log$i; done; sleep 10000000")

+	c.Assert(err, checker.IsNil)

+	c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")

+	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)

+	// wait a sec for the logs to come in

+	waitAndAssert(c, defaultReconciliationTimeout, countLogLines(d, name), checker.Equals, 3)

+

+	out, err = d.Cmd("service", "logs", "-t", name)

+	c.Assert(err, checker.IsNil)

+

+	log2Line := strings.Split(strings.Split(out, "\n")[1], " ")

+	t, err := time.Parse(time.RFC3339Nano, log2Line[0]) // timestamp log2 is written

+	c.Assert(err, checker.IsNil)

+	u := t.Add(50 * time.Millisecond) // add .05s so log1 & log2 don't show up

+	since := u.Format(time.RFC3339Nano)

+

+	out, err = d.Cmd("service", "logs", "-t", fmt.Sprintf("--since=%v", since), name)

+	c.Assert(err, checker.IsNil)

+

+	unexpected := []string{"log1", "log2"}

+	expected := []string{"log3"}

+	for _, v := range unexpected {

+		c.Assert(out, checker.Not(checker.Contains), v, check.Commentf("unexpected log message returned, since=%v", u))

+	}

+	for _, v := range expected {

+		c.Assert(out, checker.Contains, v, check.Commentf("expected log message %v, was not present, since=%v", u))

+	}

+}

+

+func (s *DockerSwarmSuite) TestServiceLogsFollow(c *check.C) {

+	d := s.AddDaemon(c, true, true)

+

+	name := "TestServiceLogsFollow"

+

+	out, err := d.Cmd("service", "create", "--name", name, "busybox", "sh", "-c", "while true; do echo log test; sleep 0.1; done")

+	c.Assert(err, checker.IsNil)

+	c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")

+

+	// make sure task has been deployed.

+	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)

+

+	args := []string{"service", "logs", "-f", name}

+	cmd := exec.Command(dockerBinary, d.PrependHostArg(args)...)

+	r, w := io.Pipe()

+	cmd.Stdout = w

+	cmd.Stderr = w

+	c.Assert(cmd.Start(), checker.IsNil)

+

+	// Make sure pipe is written to

+	ch := make(chan *logMessage)

+	done := make(chan struct{})

+	go func() {

+		reader := bufio.NewReader(r)

+		for {

+			msg := &logMessage{}

+			msg.data, _, msg.err = reader.ReadLine()

+			select {

+			case ch <- msg:

+			case <-done:

+				return

+			}

+		}

+	}()

+

+	for i := 0; i < 3; i++ {

+		msg := <-ch

+		c.Assert(msg.err, checker.IsNil)

+		c.Assert(string(msg.data), checker.Contains, "log test")

+	}

+	close(done)

+

+	c.Assert(cmd.Process.Kill(), checker.IsNil)

+}

+

+func (s *DockerSwarmSuite) TestServiceLogsTaskLogs(c *check.C) {

+	d := s.AddDaemon(c, true, true)

+

+	name := "TestServicelogsTaskLogs"

+	replicas := 2

+

+	result := icmd.RunCmd(d.Command(

+		// create a service with the name

+		"service", "create", "--name", name,

+		// which has some number of replicas

+		fmt.Sprintf("--replicas=%v", replicas),

+		// which has this the task id as an environment variable templated in

+		"--env", "TASK={{.Task.ID}}",

+		// and runs this command to print exaclty 6 logs lines

+		"busybox", "sh", "-c", "for line in $(seq 0 5); do echo $TASK log test $line; done; sleep 100000",

+	))

+	result.Assert(c, icmd.Expected{})

+	// ^^ verify that we get no error

+	// then verify that we have an id in stdout

+	id := strings.TrimSpace(result.Stdout())

+	c.Assert(id, checker.Not(checker.Equals), "")

+	// so, right here, we're basically inspecting by id and returning only

+	// the ID. if they don't match, the service doesn't exist.

+	result = icmd.RunCmd(d.Command("service", "inspect", "--format=\"{{.ID}}\"", id))

+	result.Assert(c, icmd.Expected{Out: id})

+

+	// make sure task has been deployed.

+	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, replicas)

+	waitAndAssert(c, defaultReconciliationTimeout, countLogLines(d, name), checker.Equals, 6*replicas)

+

+	// get the task ids

+	result = icmd.RunCmd(d.Command("service", "ps", "-q", name))

+	result.Assert(c, icmd.Expected{})

+	// make sure we have two tasks

+	taskIDs := strings.Split(strings.TrimSpace(result.Stdout()), "\n")

+	c.Assert(taskIDs, checker.HasLen, replicas)

+

+	for _, taskID := range taskIDs {

+		c.Logf("checking task %v", taskID)

+		result := icmd.RunCmd(d.Command("service", "logs", taskID))

+		result.Assert(c, icmd.Expected{})

+		lines := strings.Split(strings.TrimSpace(result.Stdout()), "\n")

+

+		c.Logf("checking messages for %v", taskID)

+		for i, line := range lines {

+			// make sure the message is in order

+			c.Assert(line, checker.Contains, fmt.Sprintf("log test %v", i))

+			// make sure it contains the task id

+			c.Assert(line, checker.Contains, taskID)

+		}

+	}

+}

+

+func (s *DockerSwarmSuite) TestServiceLogsTTY(c *check.C) {

+	d := s.AddDaemon(c, true, true)

+

+	name := "TestServiceLogsTTY"

+

+	result := icmd.RunCmd(d.Command(

+		// create a service

+		"service", "create",

+		// name it $name

+		"--name", name,

+		// use a TTY

+		"-t",

+		// busybox image, shell string

+		"busybox", "sh", "-c",

+		// echo to stdout and stderr

+		"echo out; (echo err 1>&2); sleep 10000",

+	))

+

+	result.Assert(c, icmd.Expected{})

+	id := strings.TrimSpace(result.Stdout())

+	c.Assert(id, checker.Not(checker.Equals), "")

+	// so, right here, we're basically inspecting by id and returning only

+	// the ID. if they don't match, the service doesn't exist.

+	result = icmd.RunCmd(d.Command("service", "inspect", "--format=\"{{.ID}}\"", id))

+	result.Assert(c, icmd.Expected{Out: id})

+

+	// make sure task has been deployed.

+	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)

+	// and make sure we have all the log lines

+	waitAndAssert(c, defaultReconciliationTimeout, countLogLines(d, name), checker.Equals, 2)

+

+	cmd := d.Command("service", "logs", name)

+	result = icmd.RunCmd(cmd)

+	// for some reason there is carriage return in the output. i think this is

+	// just expected.

+	c.Assert(result, icmd.Matches, icmd.Expected{Out: "out\r\nerr\r\n"})

+}