Watch hijacking dependency process

[adrianlungu]

Description

Given the following tasks:

  provision:
    desc: "Bring up some dependencies and write the result to .env file"
  ...

  build:
    desc: "Build the service binaries"
    sources:
      - '**/*.go'
      - 'go.mod'
      - 'go.sum'
    generates:
      - './out/bin/server'
      - './out/bin/client'
    cmds:
      - task: provision
      - go build -o ./out/bin/ ./cmd/...
    method: timestamp

  run:
    desc: "Run the services"
    dotenv: ['.env']
    deps: [run:server, run:client]
    watch: true
    sources:
      # do not include .env as it is auto-generated by the provision task
      - exclude: '.env'
      - '*.sql'
    method: none

  run:server:
    deps: [build]
    cmd: ./out/bin/server

  run:client:
    deps: [build]
    cmd: ./out/bin/client

Running task run -v seems to yield a deadlock of some kind, where we have:

task: "provision" finished
task: [build] go build -o ./out/bin/ ./cmd/...
task: received watch event: WRITE         "/Users/myself/Projects/myproject/.env"
task: [run:server] ./out/bin/server
task: skipped for file not in sources: .env

However, running task run:server works just fine.

It seems that, for some reason, having watch turned on makes the run:server step not wait for the build step any longer, so the build doesn't even get to finish, but it tries to run the binary which has not yet been created.

Haven't been able to figure out why this behavior happens though.

Version

3.45.4

Operating system

MacOS 15.7.1

Experiments Enabled

No response

Example Taskfile

[timrulebosch]

Its possible (so it seems) that the watches are installed before the tasks are run. This would be non-trivial to change (it seems).

The solution might be a level of indirection between run and build.

  build
  watch
  services
    deps: [run:server, run:client]
    watch
  run
    deps: [build]
    cmds:
      - task: services
  run:server
    deps: [build]
  run:client
    deps: [build]

So in this case, the services are build, and then run where the watch is installed. Or something similar to that.

[adrianlungu]

@timrulebosch I'm not sure that would work, it effectively disables watch, which already confirms to be working without, as per:

Note that when setting watch: true to a task, it'll only run in watch mode when running from the CLI via task my-watch-task, but won't run in watch mode if called by another task, either directly or as a dependency.

So, this indirection basically is the same thing with setting watch:false which defeats the purpose sadly.

[adrianlungu]

Funnily enough, if I include the .env file that gets written in the previous steps, I end up having

task: task "run" finished running

before it even runs the cmds in the run task 🤔

[trulede]

Right. How about using a precondition, something like this:

  provision:
    desc: "Bring up some dependencies and write the result to .env file"
  ...

  build:
    desc: "Build the service binaries"
    sources:
      - '**/*.go'
      - 'go.mod'
      - 'go.sum'
    generates:
      - './out/bin/server'
      - './out/bin/client'
    cmds:
      - task: provision
      - go build -o ./out/bin/ ./cmd/...
    method: timestamp

  run:
    desc: "Run the services"
    dotenv: ['.env']
    deps: [build, run:server, run:client]
    watch: true
    sources:
      # do not include .env as it is auto-generated by the provision task
      - exclude: '.env'
      - '*.sql'
      - './out/bin/server'
      - './out/bin/client'
    method: none

  run:server:
    cmd: ./out/bin/server
    preconditions:
      - test -f ./out/bin/server

  run:client:
    cmd: ./out/bin/client
    preconditions:
      - test -f ./out/bin/client

[adrianlungu]

@trulede tried this as well, it doesn't even reach those preconditions as it gets stuck at build.

Left it for a couple of minutes to rule out any slow behavior but it just sits there.

Funnily enough, if I change some of the watched files, I manage to unfreeze it. So it's either the watching preventing something else from continuing, or it interrupts other processes and restarts them when it notices a change.

It's a very predictable behavior though so I could even make a small repo to demonstrate it if it would help.

[trulede]

I made this taskfile, it seems to work as you want, but perhaps you try it. Just save a sql file to trigger the watch.

version: '3'

tasks:
  provision:
    cmds:
      - touch .env
  build:
    desc: "Build the service binaries"
    generates:
      - './out/bin/server'
      - './out/bin/client'
    cmds:
      - rm -rf ./out/bin
      - mkdir -p ./out/bin
      - task: provision
      - sleep 1
      - echo "foo" >> ./out/bin/server
      - echo "bar" >> ./out/bin/client
    method: timestamp

  run:
    desc: "Run the services"
    dotenv: ['.env']
    deps: [run:server, run:client]
    watch: true
    sources:
      - exclude: '.env'
      - '*.sql'
    method: none

  run:server:
    deps: [build]
    cmds: 
      - cat ./out/bin/server
      - sleep 60
      - cat ./out/bin/server

  run:client:
    deps: [build]
    cmds:
      - cat ./out/bin/client
      - sleep 60
      - cat ./out/bin/client```