Allow task output to be the value of a dynamic varible

[chrishoage]

Today the following is supported

version: '3'

tasks:
  build:
    cmds:
      - go build -ldflags="-X main.Version={{.GIT_COMMIT}}" main.go
    vars:
      GIT_COMMIT:
        sh: git log -n 1 --format=%h

I would like the following to work too

version: '3'

tasks:
  gen_hash:
    cmds:
      - openssl rand -hex 64
  build:
    cmds:
      - go build -ldflags="-X main.Version={{.GIT_COMMIT}}" main.go
    vars:
      GIT_COMMIT:
        task: gen_hash

(please don't read too much into the example, I just took the example from the docs and modified it to highlight the use case.

My actual use case is easily capturing the output from tasks to send in notifications.

In particular I have a templated docker:run that looks like:

# dockertasks.yaml
version: "3"

tasks:
  run:
    requires:
      vars:
        - image
        - container_name
        - name: pull
          enum: [always, never, missing]
    vars:
      command: '{{default "" .command}}'
      pull: '{{default "always" .pull}}'
    cmds:
      # indentation prevents folding
      - >
        docker run 
        {{if .pull}}--pull={{ .pull }}{{end}}
        {{if .privileged}}--privileged{{end}}
        {{if .rm}}--rm{{end}}
        {{range $i, $v := .volumes}}--volume={{ $v }}{{end}}
        {{range $i, $m := .mounts}}
        {{if contains $m.type "tmpfs"}}
        --mount=type=tmpfs,dst={{ $m.dst }}{{if $m.tmpfs_size}},tmpfs-size={{ $m.tmpfs_size }}{{end}}
        {{end}}
        {{if contains $m.type "bind"}}
        --mount=type=bind,src={{ $m.src }},dst={{ $m.dst }}{{if $m.readonly}},readonly{{end}}{{if $m.bind_propagation}},bind-propagation={{ $m.bind_propagation }}{{end}}
        {{end}}
        {{if contains $m.type "volume"}}
        --mount=type=volume,src={{ $m.src }},dst={{ $m.dst }}{{if $m.readonly}},readonly{{end}}
        {{end}}
        {{end}}
        {{range $i, $e := .environment}}--env={{ $e }}{{end}}
        {{range $i, $n := .networks}}--network={{ $n }}{{end}}
        {{range $i, $c := .cap_add}}--cap-add={{ $c }}{{end}}
        {{range $i, $d := .devices}}--device={{ $d }}{{end}}
        --name={{ .container_name }} 
        {{if .attach}}--interactive --tty{{end}}
        {{.image}}
        {{if .command}}{{ .command }}{{end}}

  rm:
    requires:
      vars:
        - container_name
    cmds:
      - docker rm {{ .container_name }}

  logs:
    requires:
      vars:
        - container_name
    cmds:
      - docker logs {{ .container_name }}

and in my main taskfile

version: "3"

silent: false
set: [pipefail]
shopt: [globstar]

includes:
  docker:
    taskfile: ./dockertasks.yaml
    internal: true

tasks:
  ntfy:
    requires:
      vars: [topic, title]
    vars:
      body: '{{default "" .body}}'
      tags: '{{default "" .tags}}'
      priority: '{{default "default" .priority}}'
      click: '{{default "" .click}}'
    cmds:
      - |
        curl -X POST ntfy.sh/{{ .topic }} \
          -H "Title: {{ .title }}" \
          -H "Priority: {{ .priority }}" \
          -H "Tags: {{ .tags }}" \
          -H "Click: {{ .click }}" \
          -d "{{ .body }}"

  test_one:
    cmds:
      - task: docker:run
        vars:
          image: alpine
          container_name: test
          command: echo hello world
      - defer:
          task: docker:rm
          vars:
            container_name: test
      - task: ntfy
        vars:
          topic: test
          title: Test
          body:
            task: docker:logs
            vars:
              container_name: test

Instead I have to use

      - task: ntfy
        vars:
          topic: test
          title: Test
          body:
            sh: docker logs test

Which while it works it breaks out of this little DSL I have for working with docker and it also makes --dry less useful since it tries to actually execute the sh command.

Thank you for your consideration!

[marco-m-pix4d]

If I understand correctly, you can obtain what you are looking for with YAML anchors (https://smcleod.net/2022/11/yaml-anchors-and-aliases/). It is ugly but it works:

version: '3'

tasks:

  foo:
    cmds:
      - 'echo foo: {{.OUTPUT}}'
    vars:
      OUTPUT: &OUTPUT
        sh: openssl rand -hex 64

  bar:
    cmds:
      - 'echo bar: {{.OUTPUT}}'
    vars:
      OUTPUT: *OUTPUT

and:

$ task foo
task: [foo] echo foo: 650fc2fb8fda6787244d404654...
foo: foo: 650fc2fb8fda6787244d404654...

$ task bar
task: [bar] echo bar: d4d42c8e2e271c204e8...
bar: d4d42c8e2e271c204e8...

[chrishoage]

This is close, but I think there is a lot of value for these being actual tasks.

As mentioned in my post tasks do no run the commands with --dry but sh commands do run.

By allowing a task to define the value for a var with --dry is run the command wouldn't run.

The value of the var in templates would either be empty string or the printed value of the command from the var task

[maks-oleksyuk]

The same idea has already been described in #1439. And I think this would be a really useful functionality. (+1 for this)

A short and simple use case that I would like to have:

# ...
prettier:
  label: 'Prettier'
  desc: 'Runs `prettier` command.'
  cmd: '{{.NODEJS_BIN_DIR}}/prettier {{.CLI_ARGS}}'
  silent: true
# ...
lint:prettier:
  label: 'Prettier'
  desc: 'Checks for common format issues with prettier.'
  cmds:
    - cmd: 'echo Prettier {{.PRETTIER_VERSION}}'
      vars:
        PRETTIER_VERSION:
          task: prettier
          vars: { CLI_ARGS: '-v' }
    - task: prettier
      vars: { CLI_ARGS: '. -c' }
# ... 

[trulede]

You can of course either; redirect your docker command output to a file, and then load that with a sh command into a variable; or run task directly via the sh command, capturing the output to a variable.

Running tasks and capturing output would seem possible. Here you can see how the task executor makes it possible to capture stdout/err ... that might be the easy part ... otherwise it seems similar to the 'defer' (in terms of schema), and could also be applied to 'preconditions'.