Run dependencies and exit

[hpcsc]

Problem:

• I'm working on a Go application, using Goland
• I'm trying to run a batect task to setup dependencies (database, mock api server etc) before running integration tests (as Goland run configuration, to take advantage of Goland test output window, debugging capability etc, so the tests are run directly on host machine, not through batect). I have a batect task like:

setup-dependencies:
  dependencies:
  - database
  - api-mock
  run:
    container: go
    entrypoint: echo starting            # a dummy entrypoint that does nothing and exit immediately

• I was hoping if I run it with --no-cleanup, it will run dependency containers, run the entrypoint and exit without cleaning up dependencies. But it's not exiting and just waits there to be cancelled.
• My setup is probably a bit unusual but the behavior of --no-cleanup surprised me. I would expect if the entrypoint finishes, batect should exit and leave the containers there. Is this expected behavior?

[charleskorn]

Hey @hpcsc, thanks for the question.

Are you able to provide a sample project that shows the issue you're seeing?

My setup is probably a bit unusual but the behavior of --no-cleanup surprised me. I would expect if the entrypoint finishes, batect should exit and leave the containers there. Is this expected behavior?

It should leave the containers there and running.

But it's not exiting and just waits there to be cancelled.

Could you include the output from Batect at this point? I think I can reproduce the problem but want to confirm it's the same thing that you're talking about.

Two other things you could try that might achieve the same outcome:

• You could change the entrypoint to a command that never exits (eg. sleep infinity)
• You could also look into JetBrains' recent announcement of Remote Development: https://blog.jetbrains.com/blog/2021/11/29/introducing-remote-development-for-jetbrains-ides/. I haven't yet tried this myself, but the idea is to run the backend of the IDE remotely (for example, in this case, you could run it in a container), and then the UI connects to that backend.

[hpcsc]

hi @charleskorn

here's a sample repository setup that illustrates my issue: https://github.com/hpcsc/batect-playground
This repository has 2 tasks: one starts a dependency with no healthcheck defined (mysql), the other starts a dependency with healthcheck defined in Dockerfile (rabbitmq)

I actually find 2 issues here:

• If I run ./batect --no-cleanup dependencies-no-healthcheck, it runs the main container and exits (my expected behavior). It leaves all containers there but all of them are exited. I expect database is still running and go container exits

Running dependencies-no-healthcheck...
 database: running
 go: running echo starting
 
 starting
 
 dependencies-no-healthcheck finished with exit code 0 in 1.4s.

• If I run ./batect --no-cleanup dependencies-healthcheck, it keeps waiting at Cleaning up: 2 containers (go and rabbitmq) left to remove. Only when I press Ctrl + C does it exit. This seems like a bug when dependency container has healthcheck defined

Running dependencies-healthcheck...
 rabbitmq: running
 go: running echo starting
 
 starting
 
 Cleaning up: 2 containers (go and rabbitmq) left to remove...

What I want to achieve is to run the task and let main container exits while dependency still running. Or in other words, use batect to start dependency containers. I want main container to exit so that I can use this in Goland test configuration by starting up dependencies and running go test in the same key combination. I probably can work around this by starting dependencies separately in a terminal with sleep infinity entrypoint and run tests from Goland after that but it's a bit more inconvenient.

Remote development sounds great too. I'll give that a try

[charleskorn]

Thanks for the repro repo @hpcsc. I'm seeing the same behaviour.

The first behaviour is what I expect - --no-cleanup should leave the containers there, but all stopped. The reason why this is the expected behaviour is for consistency: with this behaviour, all containers are in the same state (stopped) rather than having the main container stopped but the dependencies still running.

The second behaviour (where Batect gets stuck while cleaning up) is definitely a bug - I'll take a look at this in the next few days.

I'd be really interested to hear your experiences with remote development if you give that a go.

[charleskorn]

I've fixed the bug (038c108) and this will be part of the next release - thanks again for the detailed repro steps.

[hpcsc]

awesome, thanks for the quick fix

I had a quick look at Jetbrains remote development (haven't actually tried it out yet) but it might not fit my purpose at the moment:

• according to this blog post: Specify a host and username and provide either a key or a password, and Gateway will connect to the remote server. It checks to see whether an IDE backend is already installed and will download a new version from jetbrains.com if not. I think it's more suitable for long running container/VM/server that I need to start separately. For now I can live with running a batect task to start dependencies in a terminal and run tests from Goland against those dependencies

[nth-commit]

I'm in a similar situation.

I'm totally fine with dedicating a terminal and using sleep infinity to keep the dependencies up. I actually prefer it to something like docker-compose up as you can maintain a handle to stop the containers, which makes the lifetime much easier to manage (especially if your dev process runs on the host with static ports).

However, I can't stop the task without killing the terminal, which is a bit nasty. Is it possible to run the task in interactive mode? i.e. using docker run's "--interactive" flag.