podman

1
//go:build !remote
2

3
package libpod
4

5
import (
6
	"context"
7
	"errors"
8
	"fmt"
9
	"os"
10
	"time"
11

12
	"github.com/containers/podman/v5/libpod/define"
13
	"github.com/containers/podman/v5/libpod/events"
14
	"github.com/containers/podman/v5/libpod/logs"
15
	systemdDefine "github.com/containers/podman/v5/pkg/systemd/define"
16
	"github.com/nxadm/tail"
17
	"github.com/nxadm/tail/watch"
18
	"github.com/sirupsen/logrus"
19
)
20

21
// logDrivers stores the currently available log drivers, do not modify
22
var logDrivers []string
23

24
func init() {
25
	logDrivers = append(logDrivers, define.KubernetesLogging, define.NoLogging, define.PassthroughLogging)
26
}
27

28
// Log is a runtime function that can read one or more container logs.
29
func (r *Runtime) Log(ctx context.Context, containers []*Container, options *logs.LogOptions, logChannel chan *logs.LogLine) error {
30
	for c, ctr := range containers {
31
		if err := ctr.ReadLog(ctx, options, logChannel, int64(c)); err != nil {
32
			return err
33
		}
34
	}
35
	return nil
36
}
37

38
// ReadLog reads a container's log based on the input options and returns log lines over a channel.
39
func (c *Container) ReadLog(ctx context.Context, options *logs.LogOptions, logChannel chan *logs.LogLine, colorID int64) error {
40
	switch c.LogDriver() {
41
	case define.PassthroughLogging:
42
		// if running under systemd fallback to a more native journald reading
43
		if unitName, ok := c.config.Labels[systemdDefine.EnvVariable]; ok {
44
			return c.readFromJournal(ctx, options, logChannel, colorID, unitName)
45
		}
46
		return fmt.Errorf("this container is using the 'passthrough' log driver, cannot read logs: %w", define.ErrNoLogs)
47
	case define.NoLogging:
48
		return fmt.Errorf("this container is using the 'none' log driver, cannot read logs: %w", define.ErrNoLogs)
49
	case define.JournaldLogging:
50
		return c.readFromJournal(ctx, options, logChannel, colorID, "")
51
	case define.JSONLogging:
52
		// TODO provide a separate implementation of this when Conmon
53
		// has support.
54
		fallthrough
55
	case define.KubernetesLogging, "":
56
		return c.readFromLogFile(ctx, options, logChannel, colorID)
57
	default:
58
		return fmt.Errorf("unrecognized log driver %q, cannot read logs: %w", c.LogDriver(), define.ErrInternal)
59
	}
60
}
61

62
func (c *Container) readFromLogFile(ctx context.Context, options *logs.LogOptions, logChannel chan *logs.LogLine, colorID int64) error {
63
	t, tailLog, err := logs.GetLogFile(c.LogPath(), options)
64
	if err != nil {
65
		// If the log file does not exist, this is not fatal.
66
		if errors.Is(err, os.ErrNotExist) {
67
			return nil
68
		}
69
		return fmt.Errorf("unable to read log file %s for %s : %w", c.ID(), c.LogPath(), err)
70
	}
71
	options.WaitGroup.Add(1)
72
	go func() {
73
		if options.Until.After(time.Now()) {
74
			time.Sleep(time.Until(options.Until))
75
			if err := t.Stop(); err != nil {
76
				logrus.Errorf("Stopping logger: %v", err)
77
			}
78
		}
79
	}()
80

81
	go func() {
82
		for _, nll := range tailLog {
83
			nll.CID = c.ID()
84
			nll.CName = c.Name()
85
			nll.ColorID = colorID
86
			if nll.Since(options.Since) && nll.Until(options.Until) {
87
				logChannel <- nll
88
			}
89
		}
90
		defer options.WaitGroup.Done()
91
		var line *tail.Line
92
		var ok bool
93
		for {
94
			select {
95
			case <-ctx.Done():
96
				// the consumer has cancelled
97
				t.Kill(errors.New("hangup by client"))
98
				return
99
			case line, ok = <-t.Lines:
100
				if !ok {
101
					// channel was closed
102
					return
103
				}
104
			}
105
			nll, err := logs.NewLogLine(line.Text)
106
			if err != nil {
107
				logrus.Errorf("Getting new log line: %v", err)
108
				continue
109
			}
110
			nll.CID = c.ID()
111
			nll.CName = c.Name()
112
			nll.ColorID = colorID
113
			if nll.Since(options.Since) && nll.Until(options.Until) {
114
				logChannel <- nll
115
			}
116
		}
117
	}()
118
	// Check if container is still running or paused
119
	if options.Follow {
120
		// If the container isn't running or if we encountered an error
121
		// getting its state, instruct the logger to read the file
122
		// until EOF.
123
		state, err := c.State()
124
		if err != nil || state != define.ContainerStateRunning {
125
			if err != nil && !errors.Is(err, define.ErrNoSuchCtr) {
126
				logrus.Errorf("Getting container state: %v", err)
127
			}
128
			go func() {
129
				// Make sure to wait at least for the poll duration
130
				// before stopping the file logger (see #10675).
131
				time.Sleep(watch.POLL_DURATION)
132
				tailError := t.StopAtEOF()
133
				if tailError != nil && tailError.Error() != "tail: stop at eof" {
134
					logrus.Errorf("Stopping logger: %v", tailError)
135
				}
136
			}()
137
			return nil
138
		}
139

140
		// The container is running, so we need to wait until the container exited
141
		go func() {
142
			eventChannel := make(chan *events.Event)
143
			eventOptions := events.ReadOptions{
144
				EventChannel: eventChannel,
145
				Filters:      []string{"event=died", "container=" + c.ID()},
146
				Stream:       true,
147
			}
148
			go func() {
149
				if err := c.runtime.Events(ctx, eventOptions); err != nil {
150
					logrus.Errorf("Waiting for container to exit: %v", err)
151
				}
152
			}()
153
			// Now wait for the died event and signal to finish
154
			// reading the log until EOF.
155
			<-eventChannel
156
			// Make sure to wait at least for the poll duration
157
			// before stopping the file logger (see #10675).
158
			time.Sleep(watch.POLL_DURATION)
159
			tailError := t.StopAtEOF()
160
			if tailError != nil && tailError.Error() != "tail: stop at eof" {
161
				logrus.Errorf("Stopping logger: %v", tailError)
162
			}
163
		}()
164
	}
165
	return nil
166
}
167