Nested `.With()` funcs

[tepid current]

Hello, I have there 3 funcs

// WithUpdatedAptCache updates the apt cache on the container
func (c *NodeContainer) WithUpdatedAptCache() dagger.WithContainerFunc {
    return func(dag *dagger.Container) *dagger.Container {
        var err error

        log.Info().Msg("Updating apt cache")
        dag, err = dag.WithExec([]string{"apt", "update"}).Sync(c.ctx)
        if err != nil {
            log.Fatal().Err(err).Msg("Failed to run [apt update]")
        }

        utils.LogDebugStd(c.ctx, dag, "WithUpdatedAptCache")

        return dag
    }
}

// WithDefaultPackages installs default packages for the container
func (c *NodeContainer) WithDefaultPackages() dagger.WithContainerFunc {
    return func(dag *dagger.Container) *dagger.Container {

        pkg := []string{"pre-commit", "nano"}

        dag.With(c.WithPackages(pkg...))

        return dag
    }
}

// WithPackages installs packages for the container
func (c *NodeContainer) WithPackages(pkg ...string) dagger.WithContainerFunc {
    return func(dag *dagger.Container) *dagger.Container {
        var err error

        if len(pkg) == 0 {
            log.Info().Msg("[WithPackages] - No packages specified, skipping")
            return dag
        }

        dag.With(c.WithUpdatedAptCache())

        log.Info().Msgf("Installing packages: %v", pkg)
        pkg = append([]string{"apt", "install", "-y"}, pkg...)
        dag, err = dag.WithExec(pkg).Sync(c.ctx)
        if err != nil {
            log.Fatal().Err(err).Msg("[WithPackages] - Failed to run [apt install]")
        }

        utils.LogDebugStd(c.ctx, dag, "WithPackages")

        return dag
    }
}

This is how I initialize and call them

type NodeContainer struct {
    ctx    context.Context
    Dagger *dagger.Container
}

// NewNodeContainer returns a new NodeContainer
func NewNodeContainer(ctx context.Context, client *dagger.Client, opts *NodeContainerOpts) *NodeContainer {
    containerImage := fmt.Sprintf("%s:%s", opts.repo, opts.tag)
    node := client.Container().From(containerImage)

    log.Info().Msgf("Using Node container: %s", containerImage)

    nodeContainer := &NodeContainer{
        ctx:    ctx,
        Dagger: node,
    }

    nodeContainer.Dagger.
        With(nodeContainer.WithDefaultEnv()).
        With(nodeContainer.WithDefaultPackages()).
        With(nodeContainer.WithUpdatedNpm()).
        With(nodeContainer.WithCacheDir())

    return nodeContainer
}

But while I can see the WithUpdatedAptCache to run, when it tries to do apt install it fails.
If I run the apt update on the same func as apt install it works.

Any ideas?

---

What I'm trying to accomplish:

I have few a number of different projects, with variations on the pipeline steps, reqs etc.
I want to have a set of pre-determined steps that I can use when composing the pipeline.

Not sure if the above approach is good, or you have something else to recommend.

---

Example:

With Node image, I would build some websites, and some electron apps.
When building electron apps I also need wine64 installed, but not on websites.
"Push" on websites would be to cloudflare, but electron to s3

Hmm the WithUpdatedAptCache receives a different address?!

WithDefaultEnv - &{q:0xc00009ac00 c:{Client:0xc0001281e0} envVariable:<nil> export:<nil> id:<nil> imageRef:<nil> label:<nil> platform:<nil> publish:<nil> shellEndpoint:<nil> stderr:<nil> stdout:<nil> sync:<nil> user:<nil> workdir:<nil>}

WithPackages - before apt - &{q:0xc00009ac00 c:{Client:0xc0001281e0} envVariable:<nil> export:<nil> id:<nil> imageRef:<nil> label:<nil> platform:<nil> publish:<nil> shellEndpoint:<nil> stderr:<nil> stdout:<nil> sync:<nil> user:<nil> workdir:<nil>}

WithUpdatedAptCache - &{q:0xc000186300 c:{Client:0xc0001281e0} envVariable:<nil> export:<nil> id:<nil> imageRef:<nil> label:<nil> platform:<nil> publish:<nil> shellEndpoint:<nil> stderr:<nil> stdout:<nil> sync:<nil> user:<nil> workdir:<nil>}

WithPackages - after apt - &{q:0xc00009ac00 c:{Client:0xc0001281e0} envVariable:<nil> export:<nil> id:<nil> imageRef:<nil> label:<nil> platform:<nil> publish:<nil> shellEndpoint:<nil> stderr:<nil> stdout:<nil> sync:<nil> user:<nil> workdir:<nil>}

Nested .With() funcs

WithDefaultEnv before - &{q:0xc000134440 c:{Client:0xc0001221e0} envVariable:<nil> export:<nil> id:<nil> imageRef:<nil> label:<nil> platform:<nil> publish:<nil> shellEndpoint:<nil> stderr:<nil> stdout:<nil> sync:<nil> user:<nil> workdir:<nil>}

WithDefaultEnv after - &{q:0xc000134680 c:{Client:0xc0001221e0} envVariable:<nil> export:<nil> id:<nil> imageRef:<nil> label:<nil> platform:<nil> publish:<nil> shellEndpoint:<nil> stderr:<nil> stdout:<nil> sync:<nil> user:<nil> workdir:<nil>}

WithDefaultPackages - before packages - &{q:0xc000134680 c:{Client:0xc0001221e0} envVariable:<nil> export:<nil> id:<nil> imageRef:<nil> label:<nil> platform:<nil> publish:<nil> shellEndpoint:<nil> stderr:<nil> stdout:<nil> sync:<nil> user:<nil> workdir:<nil>}

WithPackages - before apt - &{q:0xc000134680 c:{Client:0xc0001221e0} envVariable:<nil> export:<nil> id:<nil> imageRef:<nil> label:<nil> platform:<nil> publish:<nil> shellEndpoint:<nil> stderr:<nil> stdout:<nil> sync:<nil> user:<nil> workdir:<nil>}

WithUpdatedAptCache before - &{q:0xc000134680 c:{Client:0xc0001221e0} envVariable:<nil> export:<nil> id:<nil> imageRef:<nil> label:<nil> platform:<nil> publish:<nil> shellEndpoint:<nil> stderr:<nil> stdout:<nil> sync:<nil> user:<nil> workdir:<nil>}

WithUpdatedAptCache after - &{q:0xc000134900 c:{Client:0xc0001221e0} envVariable:<nil> export:<nil> id:<nil> imageRef:<nil> label:<nil> platform:<nil> publish:<nil> shellEndpoint:<nil> stderr:<nil> stdout:<nil> sync:<nil> user:<nil> workdir:<nil>}

WithPackages - after apt - &{q:0xc000134680 c:{Client:0xc0001221e0} envVariable:<nil> export:<nil> id:<nil> imageRef:<nil> label:<nil> platform:<nil> publish:<nil> shellEndpoint:<nil> stderr:<nil> stdout:<nil> sync:<nil> user:<nil> workdir:<nil>}

The last address does not seem right

func (c *NodeContainer) WithUpdatedAptCache() dagger.WithContainerFunc {
    return func(dag *dagger.Container) *dagger.Container {
        var err error
        fmt.Printf("WithUpdatedAptCache before - %+v\n\n\n", dag)

        log.Info().Msg("Updating apt cache")
        dag, err = dag.WithExec([]string{"apt", "update"}).Sync(c.ctx)
        if err != nil {
            log.Fatal().Err(err).Msg("Failed to run [apt update]")
        }

        fmt.Printf("WithUpdatedAptCache after - %+v\n\n\n", dag)
        utils.LogDebugStd(c.ctx, dag, "WithUpdatedAptCache")

        return dag
    }
}

func (c *NodeContainer) WithDefaultPackages() dagger.WithContainerFunc {
    return func(dag *dagger.Container) *dagger.Container {

        pkg := []string{"pre-commit", "nano"}
        fmt.Printf("WithDefaultPackages - before packages - %+v\n\n\n", dag)

        // dag.With(c.WithPackages(pkg...))
        dag.With(c.WithPackages(pkg...))
        fmt.Printf("WithDefaultPackages - after packages - %+v\n\n\n", dag)

        return dag
    }
}

func (c *NodeContainer) WithPackages(pkg ...string) dagger.WithContainerFunc {
    return func(dag *dagger.Container) *dagger.Container {
        var err error

        if len(pkg) == 0 {
            log.Info().Msg("[WithPackages] - No packages specified, skipping")
            return dag
        }
        fmt.Printf("WithPackages - before apt - %+v\n\n\n", dag)

        dag.With(c.WithUpdatedAptCache())
        fmt.Printf("WithPackages - after apt - %+v\n\n\n", dag)

        log.Info().Msgf("Installing packages: %v", pkg)
        pkg = append([]string{"apt", "install", "-y"}, pkg...)
        dag, err = dag.WithExec(pkg).Sync(c.ctx)
        if err != nil {
            log.Fatal().Err(err).Msg("[WithPackages] - Failed to run [apt install]")
        }

        utils.LogDebugStd(c.ctx, dag, "WithPackages")

        return dag
    }
}

Here is where the prints are placed