synapsecns/sanguine

package dockerutil_test

import (
    "context"
    "errors"
    "fmt"
    "github.com/ory/dockertest/v3"
    "github.com/ory/dockertest/v3/docker"
    "github.com/stretchr/testify/assert"
    "github.com/synapsecns/sanguine/core/dockerutil"
    "github.com/synapsecns/sanguine/core/mocktesting"
    "github.com/synapsecns/sanguine/core/processlog"
    "os"
    "testing"
)

const stdOut = "hello world\n"

func (c *DockerSuite) TestTailContainerLogs() {
    out := testContainer(c.GetTestContext(), c.T())
    assert.FileExists(c.T(), out.CombinedFile())
    assert.FileExists(c.T(), out.StdOutFile())
    assert.FileExists(c.T(), out.StdErrFile())
}

func ExampleTailContainerLogs() {
    ctx, cancel := context.WithCancel(context.Background())

    t := mocktesting.NewMockTester("TestTailContainerLogs")
    out := testContainer(ctx, t)
    cancel()

    // get the log dir
    _ = out.LogDir()
    // get the stdout file
    _ = out.StdOutFile()
    // get the stderr file
    _ = out.StdErrFile()
    // get the combined file
    _ = out.CombinedFile()
    // Output: hello world
}

// testContainer creates a test alpine container that prints hello world.
// the return will be empty if this fails.
func testContainer(ctx context.Context, tb testing.TB) processlog.LogMetadata {
    tb.Helper()

    pool, err := dockertest.NewPool("")
    assert.Nil(tb, err)

    runOptions := &dockertest.RunOptions{
        Repository: "alpine",
        Tag:        "latest",
        Cmd:        []string{"sh", "-c", fmt.Sprintf("echo %s", stdOut)},
    }

    resource, err := pool.RunWithOptions(runOptions, func(config *docker.HostConfig) {
        config.RestartPolicy = docker.RestartPolicy{Name: "no"}
    })
    assert.Nil(tb, err)

    assert.Nil(tb, resource.Expire(60))

    logInfoChan := make(chan processlog.LogMetadata)
    go func() {
        // we can't check the error here
        _ = dockerutil.TailContainerLogs(dockerutil.WithContext(ctx), dockerutil.WithResource(resource), dockerutil.WithPool(pool), dockerutil.WithFollow(true), dockerutil.WithCallback(func(ctx context.Context, metadata processlog.LogMetadata) {
            select {
            case <-ctx.Done():
                return
            case logInfoChan <- metadata:
            }
        }))
    }()

    if err := pool.Retry(func() error {
        container, err := pool.Client.InspectContainer(resource.Container.ID)
        assert.Nil(tb, err)

        if !container.State.FinishedAt.IsZero() {
            return nil
        }
        return errors.New("container is still running")
    }); err != nil {
        tb.Fatal(err)
    }

    select {
    case <-ctx.Done():
        tb.Errorf("context canceled before container started")
    case logInfo := <-logInfoChan:
        fileContents := waitForFileContents(ctx, tb, logInfo.CombinedFile())

        assert.Nil(tb, err)

        // this is what's tested in the example
        fmt.Println(string(fileContents))
        return logInfo
    }
    return nil
}

func waitForFileContents(ctx context.Context, tb testing.TB, file string) []byte {
    tb.Helper()

    for {
        select {
        case <-ctx.Done():
            return nil
        default:
            //nolint: gosec
            fileContents, err := os.ReadFile(file)
            assert.Nil(tb, err)

            if len(fileContents) == 0 {
                continue
            }

            return fileContents
        }
    }
}