github.com/kaisenlinux/docker.io@v0.0.0-20230510090727-ea55db55fac7/engine/daemon/logger/jsonfilelog/read_test.go (about)

     1  package jsonfilelog // import "github.com/docker/docker/daemon/logger/jsonfilelog"
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/json"
     6  	"io"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/docker/docker/daemon/logger"
    11  	"gotest.tools/v3/assert"
    12  	"gotest.tools/v3/fs"
    13  )
    14  
    15  func BenchmarkJSONFileLoggerReadLogs(b *testing.B) {
    16  	tmp := fs.NewDir(b, "bench-jsonfilelog")
    17  	defer tmp.Remove()
    18  
    19  	jsonlogger, err := New(logger.Info{
    20  		ContainerID: "a7317399f3f857173c6179d44823594f8294678dea9999662e5c625b5a1c7657",
    21  		LogPath:     tmp.Join("container.log"),
    22  		Config: map[string]string{
    23  			"labels": "first,second",
    24  		},
    25  		ContainerLabels: map[string]string{
    26  			"first":  "label_value",
    27  			"second": "label_foo",
    28  		},
    29  	})
    30  	assert.NilError(b, err)
    31  	defer jsonlogger.Close()
    32  
    33  	msg := &logger.Message{
    34  		Line:      []byte("Line that thinks that it is log line from docker\n"),
    35  		Source:    "stderr",
    36  		Timestamp: time.Now().UTC(),
    37  	}
    38  
    39  	buf := bytes.NewBuffer(nil)
    40  	assert.NilError(b, marshalMessage(msg, nil, buf))
    41  	b.SetBytes(int64(buf.Len()))
    42  
    43  	b.ResetTimer()
    44  
    45  	chError := make(chan error, b.N+1)
    46  	go func() {
    47  		for i := 0; i < b.N; i++ {
    48  			chError <- jsonlogger.Log(msg)
    49  		}
    50  		chError <- jsonlogger.Close()
    51  	}()
    52  
    53  	lw := jsonlogger.(*JSONFileLogger).ReadLogs(logger.ReadConfig{Follow: true})
    54  	for {
    55  		select {
    56  		case <-lw.Msg:
    57  		case <-lw.WatchProducerGone():
    58  			return
    59  		case err := <-chError:
    60  			if err != nil {
    61  				b.Fatal(err)
    62  			}
    63  		}
    64  	}
    65  }
    66  
    67  func TestEncodeDecode(t *testing.T) {
    68  	t.Parallel()
    69  
    70  	m1 := &logger.Message{Line: []byte("hello 1"), Timestamp: time.Now(), Source: "stdout"}
    71  	m2 := &logger.Message{Line: []byte("hello 2"), Timestamp: time.Now(), Source: "stdout"}
    72  	m3 := &logger.Message{Line: []byte("hello 3"), Timestamp: time.Now(), Source: "stdout"}
    73  
    74  	buf := bytes.NewBuffer(nil)
    75  	assert.Assert(t, marshalMessage(m1, nil, buf))
    76  	assert.Assert(t, marshalMessage(m2, nil, buf))
    77  	assert.Assert(t, marshalMessage(m3, nil, buf))
    78  
    79  	dec := decodeFunc(buf)
    80  	defer dec.Close()
    81  
    82  	msg, err := dec.Decode()
    83  	assert.NilError(t, err)
    84  	assert.Assert(t, string(msg.Line) == "hello 1\n", string(msg.Line))
    85  
    86  	msg, err = dec.Decode()
    87  	assert.NilError(t, err)
    88  	assert.Assert(t, string(msg.Line) == "hello 2\n")
    89  
    90  	msg, err = dec.Decode()
    91  	assert.NilError(t, err)
    92  	assert.Assert(t, string(msg.Line) == "hello 3\n")
    93  
    94  	_, err = dec.Decode()
    95  	assert.Assert(t, err == io.EOF)
    96  }
    97  
    98  func TestUnexpectedEOF(t *testing.T) {
    99  	buf := bytes.NewBuffer(nil)
   100  	msg1 := &logger.Message{Timestamp: time.Now(), Line: []byte("hello1")}
   101  	msg2 := &logger.Message{Timestamp: time.Now(), Line: []byte("hello2")}
   102  
   103  	err := marshalMessage(msg1, json.RawMessage{}, buf)
   104  	assert.NilError(t, err)
   105  	err = marshalMessage(msg2, json.RawMessage{}, buf)
   106  	assert.NilError(t, err)
   107  
   108  	r := &readerWithErr{
   109  		err:   io.EOF,
   110  		after: buf.Len() / 4,
   111  		r:     buf,
   112  	}
   113  	dec := &decoder{rdr: r, maxRetry: 1}
   114  
   115  	_, err = dec.Decode()
   116  	assert.Error(t, err, io.ErrUnexpectedEOF.Error())
   117  	// again just to check
   118  	_, err = dec.Decode()
   119  	assert.Error(t, err, io.ErrUnexpectedEOF.Error())
   120  
   121  	// reset the error
   122  	// from here all reads should succeed until we get EOF on the underlying reader
   123  	r.err = nil
   124  
   125  	msg, err := dec.Decode()
   126  	assert.NilError(t, err)
   127  	assert.Equal(t, string(msg1.Line)+"\n", string(msg.Line))
   128  
   129  	msg, err = dec.Decode()
   130  	assert.NilError(t, err)
   131  	assert.Equal(t, string(msg2.Line)+"\n", string(msg.Line))
   132  
   133  	_, err = dec.Decode()
   134  	assert.Error(t, err, io.EOF.Error())
   135  }
   136  
   137  type readerWithErr struct {
   138  	err   error
   139  	after int
   140  	r     io.Reader
   141  	read  int
   142  }
   143  
   144  func (r *readerWithErr) Read(p []byte) (int, error) {
   145  	if r.err != nil && r.read > r.after {
   146  		return 0, r.err
   147  	}
   148  
   149  	n, err := r.r.Read(p[:1])
   150  	if n > 0 {
   151  		r.read += n
   152  	}
   153  	return n, err
   154  }