Bundle commands and run them in a batch at the end

[alfredbez]

I'd like to run some commands on the host and other inside a running docker container. I've currently more than 20 actions registered and if all of them run, the overhead by running the commands inside docker is a bit annoying.

Would it be possible to collect certain commands and run it in a batch at the end of the process? It's a wild idea and maybe too complex, but this is what I have in my head right now

current captainhook.json:

{
  "config": {
    "bootstrap": "vendor/autoload.php"
  },
  "commit-msg": {
    "enabled": false,
    "actions": []
  },
  "pre-push": {
    "enabled": false,
    "actions": []
  },
  "pre-commit": {
    "enabled": false,
    "actions": []
  },
  "post-change": {
    "enabled": true,
    "actions": [
      {
        "action": "custom-docker-command vendor/bin/console first:command",
        "options": {},
        "conditions": [
          {
            "exec": "\\CaptainHook\\App\\Hook\\Condition\\FileChanged\\Any",
            "args": [
              ["src/*/Schema/*.json"]
            ]
          }
        ]
      },
      {
        "action": "vendor/bin/console this:can:run:on:the:host",
        "options": {},
        "conditions": [
          {
            "exec": "\\CaptainHook\\App\\Hook\\Condition\\FileChanged\\Any",
            "args": [
              ["composer.lock"]
            ]
          }
        ]
      },
      {
        "action": "custom-docker-command vendor/bin/console my:command",
        "options": {},
        "conditions": [
          {
            "exec": "\\CaptainHook\\App\\Hook\\Condition\\FileChanged\\Any",
            "args": [
              [
                "src/*/*SomeSuffix.php"
              ]
            ]
          }
        ]
      }
    ]
  }
}

new idea:

{
  "config": {
    "bootstrap": "vendor/autoload.php",
    "custom": {
      "batch-prefix": "custom-docker-command"
    }
  },
  "commit-msg": {
    "enabled": false,
    "actions": []
  },
  "pre-push": {
    "enabled": false,
    "actions": []
  },
  "pre-commit": {
    "enabled": false,
    "actions": []
  },
  "post-change": {
    "enabled": true,
    "actions": [
      {
        "action": "vendor/bin/console first:command",
        "options": {
            "batch": true
        },
        "conditions": [
          {
            "exec": "\\CaptainHook\\App\\Hook\\Condition\\FileChanged\\Any",
            "args": [
              ["src/*/Schema/*.json"]
            ]
          }
        ]
      },
      {
        "action": "vendor/bin/console this:can:run:on:the:host",
        "options": {},
        "conditions": [
          {
            "exec": "\\CaptainHook\\App\\Hook\\Condition\\FileChanged\\Any",
            "args": [
              ["composer.lock"]
            ]
          }
        ]
      },
      {
        "action": "vendor/bin/console my:command",
        "options": {
            "batch": true
        },
        "conditions": [
          {
            "exec": "\\CaptainHook\\App\\Hook\\Condition\\FileChanged\\Any",
            "args": [
              [
                "src/*/*SomeSuffix.php"
              ]
            ]
          }
        ]
      }
    ]
  }
}

This is more like pseudo code and won't work ootb of course. The main difference would be what captainhook executes under the hood for both versions:

# version 1
custom-docker-command vendor/bin/console first:command
vendor/bin/console this:can:run:on:the:host
custom-docker-command vendor/bin/console my:command

vs

# version 2
vendor/bin/console this:can:run:on:the:host
custom-docker-command "vendor/bin/console first:command && vendor/bin/console my:command"

[sebastianfeldmann]

If I understand it correctly the main goal is to run multiple commands within the same container right.
So you don't have to spin up the container each time.

You could do something like.

docker run -d my-image my-command

This command starts a new container and then detaches the container so that it runs in the background.
To run a command inside this container, you can use the docker exec command like this:

docker exec my-container echo "Hello, world!"

This command runs the echo command inside the my-container container and outputs "Hello, world!" to the terminal. Note that you need to specify the name or ID of the container you want to execute the command in, rather than the name of the image.

So you could setup your actions in a way that they run docker run -d... and then only docker exec.... I don't know if that is feasible or bringing any significant improvements in your case but the only other solution I can think of is to create a custom Action that creates the container and then runs multiple commands in it. Something like this:

      {
        "action": "\\CaptainHook\\App\\Hook\\DockerCommandQueue",
        "options": {
          "container": "container name to run detached with -d",
          "commands": [
            "command 1",
            "command 2",
            "command 3"
          ]
        }
      }

You could create such an Action yourself and even provide a pull request for it ;)
I don't use docker that much so for me to build something like this would take a while.
I know this will kill the ability to have different conditions for different docker commands but that's the only way the Cap'n can or should support this.

The reason I'm not in favor of making the Cap'n aware of the connection between different actions are the advantages the independence provides. I'm heavily looking into allow async execution of tasks. So you can run multiple Actions in parallel.
That's basically a feature request since the beginning of time and finally I have a plan to make it work for version 6 of the Cap'n.

Adding coupling between actions would only further impede the implementation of that feature.

Don't think I just want to shut you down. If you want to further discuss this or have any other questions feel free ask them at any time.