synapsecns/sanguine

package dockerutil

import (
    "context"
    "github.com/ory/dockertest/v3"
    "github.com/ory/dockertest/v3/docker"
    "github.com/synapsecns/sanguine/core/processlog"
)

// Callback is a callback function that is called when a container log process is started.
type Callback func(ctx context.Context, metadata processlog.LogMetadata)

type logOptions struct {
    logOptions docker.LogsOptions
    //nolint: containedctx
    ctx            context.Context
    pool           *dockertest.Pool
    callback       Callback
    processOptions []processlog.StdStreamLogArgsOption
}

// Option is a function that configures a logOptions struct.
type Option func(*logOptions) error

// WithContext sets the context for the TailContainerLogs function.
func WithContext(ctx context.Context) Option {
    return func(opts *logOptions) error {
        if ctx == nil {
            return newContextError("context is nil")
        }
        opts.ctx = ctx
        return nil
    }
}

// WithResource sets the resource for the TailContainerLogs function.
func WithResource(resource *dockertest.Resource) Option {
    return func(opts *logOptions) error {
        if resource == nil {
            return newResourceError("resource is nil")
        }
        opts.logOptions.Container = resource.Container.ID
        return nil
    }
}

// WithPool sets the pool for the TailContainerLogs function.
func WithPool(pool *dockertest.Pool) Option {
    return func(opts *logOptions) error {
        if pool == nil {
            return newPoolError("pool is nil")
        }
        opts.pool = pool
        return nil
    }
}

// WithStderr sets the Stderr option for the TailContainerLogs function.
func WithStderr(stderr bool) Option {
    return func(opts *logOptions) error {
        opts.logOptions.Stderr = stderr
        return nil
    }
}

// WithStdout sets the Stdout option for the TailContainerLogs function.
func WithStdout(stdout bool) Option {
    return func(opts *logOptions) error {
        opts.logOptions.Stdout = stdout
        return nil
    }
}

// WithFollow sets the Follow option for the TailContainerLogs function.
func WithFollow(follow bool) Option {
    return func(opts *logOptions) error {
        opts.logOptions.Follow = follow
        return nil
    }
}

// WithTimestamps sets the Timestamps option for the TailContainerLogs function.
func WithTimestamps(timestamps bool) Option {
    return func(opts *logOptions) error {
        opts.logOptions.Timestamps = timestamps
        return nil
    }
}

// WithRawTerminal sets the RawTerminal option for the TailContainerLogs function.
func WithRawTerminal(rawTerminal bool) Option {
    return func(opts *logOptions) error {
        opts.logOptions.RawTerminal = rawTerminal
        return nil
    }
}

// WithSince sets the Since option for the TailContainerLogs function.
func WithSince(since int64) Option {
    return func(opts *logOptions) error {
        opts.logOptions.Since = since
        return nil
    }
}

// WithProcessLogOptions sets the process log options for the TailContainerLogs function.
func WithProcessLogOptions(customOpts ...processlog.StdStreamLogArgsOption) Option {
    return func(opts *logOptions) error {
        opts.processOptions = customOpts
        return nil
    }
}

// WithCallback sets the callback function for the TailContainerLogs function.
func WithCallback(callback Callback) Option {
    return func(opts *logOptions) error {
        if callback == nil {
            return newCallbackError("callback is not provided")
        }
        opts.callback = callback
        return nil
    }
}

// ValidateOptions validates the options for the TailContainerLogs function.
func ValidateOptions(opts ...Option) error {
    logOpts := &logOptions{}

    for _, opt := range opts {
        if err := opt(logOpts); err != nil {
            return optionError{err}
        }
    }

    if logOpts.ctx == nil {
        return optionError{newContextError("context is not provided")}
    }

    if logOpts.logOptions.Container == "" {
        return optionError{newResourceError("resource is not provided")}
    }

    if logOpts.pool == nil {
        return optionError{newPoolError("pool is not provided")}
    }

    return nil
}

type optionError struct {
    err error
}

func (e optionError) Error() string {
    return e.err.Error()
}

type contextError struct {
    errMsg string
}

func newContextError(errMsg string) contextError {
    return contextError{errMsg: errMsg}
}

func (e contextError) Error() string {
    return e.errMsg
}

type resourceError struct {
    errMsg string
}

func newResourceError(errMsg string) resourceError {
    return resourceError{errMsg: errMsg}
}

func (e resourceError) Error() string {
    return e.errMsg
}

type poolError struct {
    errMsg string
}

func newPoolError(errMsg string) poolError {
    return poolError{errMsg: errMsg}
}

func (e poolError) Error() string {
    return e.errMsg
}

type callbackError struct {
    errMsg string
}

func newCallbackError(errMsg string) callbackError {
    return callbackError{errMsg: errMsg}
}

func (e callbackError) Error() string {
    return e.errMsg
}