`--watch` should start new process after old process stopped

[trim21]

• Task version: 3.36.0
• Operating system: debian 10
• Experiments enabled: no

I have a simple go program

package main

import (
	"io"
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("/", func(writer http.ResponseWriter, r *http.Request) {
		print(r.URL.Query().Encode())
		io.WriteString(writer, "hello world 2")
	})

	log.Fatal(http.ListenAndServe(":8001", http.DefaultServeMux))
}

and task file:

version: 3

tasks:
  s:
    sources:
      - '*.go'
    cmd: go run main.go

whan I run it with task s --watch I encounter a error with 2024/05/02 13:38:59 listen tcp :8001: bind: address already in use.

It looks like task didn't stop old process cleanly before it start a new process?

[trim21]

this works as expected

version: 3

tasks:
  build:
    sources:
      - '*.go'
    generates:
      - out
    cmd: go build -o out main.go

  s:
    deps: [ build ]
    cmd: ./out

[eduardolat]

I can confirm that this works but the first one not

this works as expected

version: 3

tasks:
  build:
    sources:
      - '*.go'
    generates:
      - out
    cmd: go build -o out main.go

  s:
    deps: [ build ]
    cmd: ./out

[noahfraiture]

Hello, I would like to point out that this problem stills occurs. The second configuration works because there's retries, but there's still fail message

2025/07/22 14:53:41 listen tcp :8080: bind: address already in use
task: Failed to run task "run-website": exit status 1

and sometimes it requires to save the files multiple times to force more retry because the 3 retry in case of an error are not enough and the previous process has not stopped yet. It would be good to either ensure the previous process stopped, or add a delay between the retry

[sedyh]

Hmm. It's still occurs. Even with go build.

Endless loop after pkill and ensuring that no one is listening this port:

(✓) Complete [ updates=0 duration=5.0075ms ]
(✓) Complete [ updates=0 duration=2.887667ms ]
23:29:04 ERR server error=listen: listen tcp :7111: bind: address already in use
23:29:04 INF stopped
23:29:04 ERR server error=listen: listen tcp :7111: bind: address already in use
23:29:04 INF stopped
23:29:04 INF started listen=:7111
(✓) Complete [ updates=0 duration=1.849875ms ]
(✓) Complete [ updates=0 duration=2.167958ms ]

Config:

dev:
  watch: true
  deps: [gen, run]
  sources:
    - '**/*.go'
    - '**/*.templ'
    - '**/*.css'
  cmds:
    - go tool task gen
     - go tool task run
gen: go tool templ generate
  run:
    generates:
      - panel
    cmds:
      - go build -o panel ./cmd/panel && ./panel

Also, I saw this advice on the wiki:

It's advised to avoid running commands as go run and prefer go build [...] && ./binary instead.

Looks like its doesn't really matter what to choose, they are both failing to kill the app.

[trulede]

The original problem here is solved.

Processes can take some time to shutdown and release system resources (ports). There are many ways to do that reliably. Its also possible to call net.Listen() to wait for a port to be available before your application tries to use that port.

Docker containers are a good way to manage these things. The docker cli makes it easy to start/stop/kill any application.