| // +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" |
| "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) { |
| out, err := d.Cmd("service", "logs", "-t", name) |
| c.Assert(err, checker.IsNil) |
| lines := strings.Split(strings.TrimSpace(out), "\n") |
| return len(lines), check.Commentf("output, %q", string(out)) |
| } |
| } |
| |
| 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 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) |
| // and make sure we have all the log lines |
| waitAndAssert(c, defaultReconciliationTimeout, countLogLines(d, name), checker.Equals, 6) |
| |
| args := []string{"service", "logs", name} |
| cmd := exec.Command(dockerBinary, d.PrependHostArg(args)...) |
| r, w := io.Pipe() |
| cmd.Stdout = w |
| cmd.Stderr = w |
| c.Assert(cmd.Start(), checker.IsNil) |
| |
| reader := bufio.NewReader(r) |
| // 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 := 1; i <= 6; i++ { |
| msg := &logMessage{} |
| msg.data, _, msg.err = reader.ReadLine() |
| c.Assert(msg.err, checker.IsNil) |
| c.Assert(string(msg.data), 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) |
| |
| args := []string{"service", "logs", "--tail=2", name} |
| cmd := exec.Command(dockerBinary, d.PrependHostArg(args)...) |
| r, w := io.Pipe() |
| cmd.Stdout = w |
| cmd.Stderr = w |
| c.Assert(cmd.Start(), checker.IsNil) |
| |
| reader := bufio.NewReader(r) |
| // see TestServiceLogsCompleteness for comments about logs being well- |
| // ordered, if this flakes |
| for i := 5; i <= 6; i++ { |
| msg := &logMessage{} |
| msg.data, _, msg.err = reader.ReadLine() |
| c.Assert(msg.err, checker.IsNil) |
| c.Assert(string(msg.data), checker.Contains, fmt.Sprintf("log test %v", i)) |
| } |
| } |
| |
| 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) |
| } |