#variant - April 2020

job "bar" {
  import = "./path/to/dir"`
}

module "yourapp" {
  dependency "github_release" "variant2libs" {
    source = "cloudposse/variant2libs"
    version = "> 1.0.0"
  }

   directory "lib/variant2libs" {
     source = "<http://github.com/cloudposse/variant2libs?ref=${dep.variant2libs.version}|github.com/cloudposse/variant2libs?ref=${dep.variant2libs.version}>"
   }

Error: accepts between 1 and 1 arg(s), received 0
Usage:
  mycli terraform init [flags]

Flags:
      --cachedir string   Module cache folder
  -h, --help              help for init

Global Flags:
      --env string   Environment to operate on

job "terraform init" {
  parameter "project" {
    type = string
    description = "Project to provision"
  }
...
}

  parameter "project" {
    type = string
    description = "Project to provision"
  }

  option "cachedir" {
    type = string
    default = try(".modules/${param.project}")
    description = "Module cache folder"
  }

job "x" {
  parameter "a" {
    type = string
    default = "foo"
  }
  
  parameter "b" {
    type = string
  }
}

a more terse way to express a lot of variables

locals {
   moduledir = "${opt.cachedir}"
   id = "${opt.namespace}-${opt.stage}-${opt.name}"
....
}

variable "moduledir" {
   value = "${opt.cachedir}"
}

variable "id" {
  value = "${opt.namespace}-${opt.stage}-${opt.name}"
}

Error: handler for type tuple not implemneted yet

job "shell" {
  description = "Run a command in a shell"
  parameter "commands" {
    description = "List of commands to execute"
    type = list(string)
  }

  exec {
    command = "bash"
    args = ["-c", join("\n", param.commands)]
  }
}

job "shell" {
  parameter "script" {
    type = string
  }

  parameter "path" {
    type = string
  }

  exec {
    command = "bash"
    args = ["-c", param.script]
    env = {
      PATH = param.path
    }
  }
}

job "shell" {
  parameter "commands" {
    type = list(string)
  }

  parameter "path" {
    type = string
  }

  exec {
    command = "bash"
    args = ["-c", join("\n", param.commands)]
    env = {
      PATH = param.path
    }
  }
}

job "app deploy" {
  option "path" {
    type = string
    default = ".:${abspath("${context.sourcedir}/mocks/kubectl")}:/bin:/usr/bin"
  }
  run "shell" {
    commands = [
    "kubectl -n ${opt.namespace} apply -f ${context.sourcedir}/manifests/"
    ]
    path = opt.path
  }

  assert "path" {
    condition = opt.path != ""
  }
}

commands = list([
    "kubectl -n ${opt.namespace} apply -f ${context.sourcedir}/manifests/"
    ])

commands = list(
    "kubectl", "-n", opt.namespace, "apply", "-f", "${context.sourcedir}/manifests/"
    )

job `terraform` {
  paramter "workdir" {
    type = string
  }

  exec {
    command = "bash"
    args = ["-c", "cd ${param.workdir}; terraform ...."]
  }
}

if one job cd's into a directory, will the next job be run there?

# static deps (like steps in variant)
target: dep1 dep2 dep3

# dynamically compute deps
DEPS = $(shell echo dep1 dep2 dep3) 
target: $(DEPS)

job "dep1" {
}

job "dep2" {
}

job "terraform init all" {
  concurrency = 2

  step "run-dep1" {
    run "dep1" {
    ...
    }
  }

  step "run-dep2" {
    run "dep2" {
    ...
    }
  }

  step "do something with dep1 and dep2" {
    needs = ["run-dep1", "run-dep2"]
    run "something" {
    }
  }
}

job "terraform init all" {
  needs = ["dep1", "dep2"]
}

job "terraform init all" {
   need "dep1" {
     param1 = "paramvalue"
     opt1 = "optvalue"
  }
  need "dep2" {
    param1 = "paramvalue"}
  }

   run "foo" {
     ...
   }
}

job "terraform init all" {
  concurrency = 2
   step "run-dep1" {
     run "dep1" {
       param1 = "paramvalue"
       opt1 = "optvalue"
     }
  }
  step "run-dep2" {
    run "dep2" {
      param1 = "paramvalue"}
    }
  }
  step "run-foo" {
    needs = ["run-dep1", "run-dep2"]
    run "foo" {
      ...
    }
  }
}

with the step notation, I have to know ahead of time each project

variable "projects" {
  value = [
    map("dir", "web"),
    map("dir", "infra"),
  }
}

step "all-deps" {
  items = var.projects
  run "terraform init" {
    dir = item.dir
  }
}

job "terraform init" {
  parameter "project" {
    ...
  }
  option "extra_args" {
    ... 
  }
  exec {
    ...
    args = opt.extra_args
  }
}

job "terraform init all" {
  # note this list of "depends on" can be calculated dynamically
  depends_on = ["terrraform init eks", "terraform init efs"]
  extra_args = ["-refresh=true"]
}

job "terraform init all" {
   depends_on "terrraform init" {
     project = "eks"
  }
  depends_on  "terrraform init" {
     project = "efs"
  }

projects:
  eks:
    module: "git::<https://github.com/cloudposse/terraform-root-modules.git//aws/eks?ref=tags/0.122.0>"
    min_nodes: 3
    max_nodes: 10
  efs:
    module: "git::<https://github.com/cloudposse/terraform-root-modules.git//aws/efs?ref=tags/0.122.0>"

depends_on = ["terrraform init eks", "terraform init efs"]

extra_args = ["-refresh=true"]

write a command parser that should behave equivalent to shells

job "terraform init all" {
  exec {
    # exec will be expanded to multiple concurrent execs by replacing `item` in `args` to each item in this tuple:
    items = ["efs", "eks"]
    cmd = "variant"
    args = ["run", "terraform", "init", item, "--refresh=true"]
  }
}

job "terraform init all" {
  need {
    # this step will be expanded to multiple concurrent steps by replacing `item` in the run body to each item in this tuple:
    items = ["efs", "eks"]

    run "terraform init" {
      project = item
      refresh = true
    }
  }
}

job "terraform init all" {
  depends_on {
    # this step will be expanded to multiple concurrent steps by replacing `item` in the run body to each item in this tuple:
    items = ["efs", "eks"]

    run "terraform init" {
      project = item
      refresh = true
    }
  }
}

job "terraform init all" {
  description = "Init all projects"
  depends_on "terraform init" {
    items = keys(conf.terraform.projects)
    args = {
      project = item
      env = opt.env
    }
  }
}

The keys are returned in lexicographical order, ensuring that the result will be identical as long as the keys in the map don't change.

I’m not sure if integrations with external services (e.g. Slack) should be inside variant core

a lot of half-baked integrations inside the core (Docker runner, Github actions, etc), which are not maintained for the obvious reasons

as v1 is not supported anymore

job "shell" {
  description = "Run a command in a shell"
  private = true

  option "dir" {
    default = ""
    description = "Directory to run the command"
    type = string
  }

  option "env" {
    default = {}
    description = "Directory to run the command"
    type = map(string)
  }

  parameter "commands" {
    description = "List of commands to execute"
    type = list(string)
  }

  exec {
    dir = opt.dir
    env = opt.env
    command = "bash"
    args = ["-c", join("\n", param.commands)]
  }
}

job "tf clean" {
  run "tfshell" {
    project  = opt.project
    tenant   = opt.tenant
    commands = ["rm -rf .terraform *.planfile"]
  }
}

Error: handler for type object not implemneted yet

job "shell" {
  description = "Run a command in a shell"
  private = true

  option "dir" {
    default = ""
    description = "Directory to run the command"
    type = string
  }

  option "env" {
    default = {}
    description = "Directory to run the command"
    type = map(string)
  }

  parameter "commands" {
    description = "List of commands to execute"
    type = list(string)
  }

  exec {
    dir = opt.dir
    env = opt.env
    command = "bash"
    args = ["-c", join("\n", param.commands)]
  }
}

  run "shell" {
    commands = param.commands
    dir      = "../projects/helmfiles/${opt.project}"
    project  = opt.project
    tenant   = opt.tenant

    env = {
      AWS_PROFILE = "nbo-${opt.tenant}-helm"
      TENANT      = opt.tenant
      PROJECT     = opt.project
      KUBECONFIG  = "~/.kube/kubecfg.${opt.tenant}-helm"
    }
  }

in ./helmfile.yaml: error during ../environments.yaml.part.0 parsing: template: stringTemplate:22:9: executing "stringTemplate" at <exec "yq" (list "read" (printf "../../../tenants/%v.yaml" (env "TENANT")) (printf "projects.helmfile.%v.values" (env "PROJECT")))>: error calling exec: exec: "yq": executable file not found in $PATH

COMMAND:
  yq read, ../../../tenants/acme.yaml, projects.helmfile.reloader.values

ERROR:
  exec: "yq": executable file not found in $PATH
Error: command "helmfile --environment tenant diff" in "../projects/helmfiles/reloader": exit status 1

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x8 pc=0x1f9bafe]

goroutine 1 [running]:
<http://github.com/mumoshu/variant2/pkg/app.ctyToGo(0x283bb40|github.com/mumoshu/variant2/pkg/app.ctyToGo(0x283bb40>, 0xc0004b3da0, 0x21295e0, 0xc0004b3dc0, 0xc0004b3d80, 0x0, 0x0, 0x0)
        /home/runner/work/variant2/variant2/pkg/app/app.go:1271 +0x2be
<http://github.com/mumoshu/variant2/pkg/app.(*App).execRunInternal(0xc0000a38c0|github.com/mumoshu/variant2/pkg/app.(*App).execRunInternal(0xc0000a38c0>, 0xc000031280, 0xc0004b3c80, 0xc00000c3c0, 0x0, 0x0, 0x0)
        /home/runner/work/variant2/variant2/pkg/app/app.go:1048 +0x1bf
<http://github.com/mumoshu/variant2/pkg/app.(*App).execRun(0xc0000a38c0|github.com/mumoshu/variant2/pkg/app.(*App).execRun(0xc0000a38c0>, 0xc000031280, 0xc0004b3c80, 0xc00000c3c0, 0x28268c0, 0xc00049dc70, 0x0, 0x0, 0x0)
        /home/runner/work/variant2/variant2/pkg/app/app.go:1187 +0x81
<http://github.com/mumoshu/variant2/pkg/app.(*App).execJob(0xc0000a38c0|github.com/mumoshu/variant2/pkg/app.(*App).execJob(0xc0000a38c0>, 0xc000031280, 0xc0005e6fd0, 0x7, 0x0, 0x283b980, 0xc00045f740, 0x0, 0x0, 0x0, ...)
        /home/runner/work/variant2/variant2/pkg/app/app.go:812 +0x5fa
<http://github.com/mumoshu/variant2/pkg/app.(*App).Job.func1(0x0|github.com/mumoshu/variant2/pkg/app.(*App).Job.func1(0x0>, 0x0, 0x0)
        /home/runner/work/variant2/variant2/pkg/app/app.go:626 +0x9d2
<http://github.com/mumoshu/variant2/pkg/app.(*App).Run(0xc0000a38c0|github.com/mumoshu/variant2/pkg/app.(*App).Run(0xc0000a38c0>, 0xc0005e6fd0, 0x7, 0xc00052c5d0, 0xc00052c600, 0xc00058b9e0, 0x1, 0x1, 0x0, 0x0, ...)
        /home/runner/work/variant2/variant2/pkg/app/app.go:497 +0xc3
<http://github.com/mumoshu/variant2.(*Runner).Cobra.func1(0xc0005e1180|github.com/mumoshu/variant2.(*Runner).Cobra.func1(0xc0005e1180>, 0xc000520740, 0x0, 0x4, 0x0, 0x0)
        /home/runner/work/variant2/variant2/variant.go:624 +0x114
<http://github.com/spf13/cobra.(*Command).execute(0xc0005e1180|github.com/spf13/cobra.(*Command).execute(0xc0005e1180>, 0xc000520700, 0x4, 0x4, 0xc0005e1180, 0xc000520700)
        /home/runner/go/pkg/mod/github.com/spf13/cobra@v0.0.5/command.go:826 +0x460
<http://github.com/spf13/cobra.(*Command).ExecuteC(0xc000032780|github.com/spf13/cobra.(*Command).ExecuteC(0xc000032780>, 0x2812d00, 0xc000098010, 0x2812d00)
        /home/runner/go/pkg/mod/github.com/spf13/cobra@v0.0.5/command.go:914 +0x2fb
<http://github.com/spf13/cobra.(*Command).Execute(...)|github.com/spf13/cobra.(*Command).Execute(...)>
        /home/runner/go/pkg/mod/github.com/spf13/cobra@v0.0.5/command.go:864
<http://github.com/mumoshu/variant2.(*Runner).Run(0xc000483090|github.com/mumoshu/variant2.(*Runner).Run(0xc000483090>, 0xc00024e0f0, 0x6, 0x6, 0xc00058bd78, 0x1, 0x1, 0x0, 0x0)
        /home/runner/work/variant2/variant2/variant.go:754 +0x2cc
<http://github.com/mumoshu/variant2.Main.Run(0x7ffeefbff81f|github.com/mumoshu/variant2.Main.Run(0x7ffeefbff81f>, 0x3, 0x0, 0x0, 0x0, 0x7ffeefbff818, 0xa, 0x2812d00, 0xc000098008, 0x2812d00, ...)
        /home/runner/work/variant2/variant2/variant.go:359 +0x12d
main.main()
        /home/runner/work/variant2/variant2/pkg/cmd/main.go:13 +0xb8

  variable "asplit" {
    type = list(string)
    value = split(".", opt.a)
  }

  variable "cmd" {
    type = string
    value = var.asplit[0]
  }

  variable "project" {
    type = string
    value = var.asplit[1]
  }

Error: Unknown variable

  on ../cli/main.variant line 51:
  (source code not available)

There is no variable named "var".

Error: Unknown variable

  on ../cli/main.variant line 51:
  (source code not available)

There is no variable named "var".

Error: ../cli/main.variant:51,13-16: Unknown variable; There is no variable named "var".

can I have a variable depend on a variable?

option "dry-run" {
  default     = false
  description = "simulate an install"
  type        = bool
}

job "deploy switch": option "dry-run": can't convert Go string to boolError: job "deploy switch": option "dry-run": can't convert Go string to bool

  depends_on "deploy switch" {
    items = conf.file.order

    args = {
      dry-run = opt.dry-run
      item    = item
      tenant  = param.tenant
    }
  }

  step "deploy run" {
    run {
      job = "${var.subcommand} deploy"

      with = {
        project = var.project
        tenant  = param.tenant
      }
    }
  } 

  # step "deploy run" {
    run {
      job = "${var.subcommand} deploy"

      with = {
        project = var.project
        tenant  = param.tenant
      }
    }
  # }

job "example" {
  step "one" {
    run "x" {
    }
  }

  step "two" {
    run "y" {
    }
  }
}

option "namespace"
  default = "cp"

job "b"
  echo opt.namespace // "hi"

  run "c" // no namespace set here

  run "d"
    namespace = opt.namespace

job "c"
  echo opt.namespace // "cp"

job "d"
  echo opt.namespace // "hi"

loop item as [call1, call2, call3]
  item()

Right now it continues to try and run 3 even though I need 2 to pass before 3 runs.

exec jobs in a loop and stop when they fail

[10:35 AM] Is there a concept of looping outside of depends on?

this seems like building a dependency graph that each next job depends on its previous job?

order:
  - terraform.account
  - terraform.iam-tenant-roles
  - terraform.cloudtrail
  - terraform.vpc

  depends_on "deploy switch" {
    items = conf.file.order

    args = {
      item   = item
      tenant = param.tenant
    }
  }

job "deploy switch" {
  run {
    job = "${var.subcommand} deploy"

    with = {
      project = var.project
      tenant  = param.tenant
    }
  }
}

Where's/What's the silver bullet for building an enterprise-grade Web UI today?

  case "ok" {
    tenant = "acme"
    exitstatus = 0
    err = ""
  }

panic: handler for type dynamic not implemented yet [recovered]
        panic: handler for type dynamic not implemented yet

goroutine 10 [running]:
testing.tRunner.func1(0xc0000cb500)
        /opt/hostedtoolcache/go/1.13.10/x64/src/testing/testing.go:874 +0x3a3
panic(0x21ebee0, 0xc0000968e0)
        /opt/hostedtoolcache/go/1.13.10/x64/src/runtime/panic.go:679 +0x1b2
<http://github.com/mumoshu/variant2/pkg/app.(*App).execAssert(0xc00020b080|github.com/mumoshu/variant2/pkg/app.(*App).execAssert(0xc00020b080>, 0xc0005cc980, 0xc0004dda0a, 0x5, 0x2840660, 0xc000598a80, 0x0, 0x0)
        /home/runner/work/variant2/variant2/pkg/app/app.go:965 +0x9d0
<http://github.com/mumoshu/variant2/pkg/app.(*App).execTestCase(0xc00020b080|github.com/mumoshu/variant2/pkg/app.(*App).execTestCase(0xc00020b080>, 0xc000035740, 0x12, 0xc0005b5ec0, 0x1, 0x1, 0xc0005ab5e0, 0x1, 0x1, 0xc000035820, ...)
        /home/runner/work/variant2/variant2/pkg/app/app.go:1091 +0x659
<http://github.com/mumoshu/variant2/pkg/app.(*App).execTest.func1(0xc0000cb500)|github.com/mumoshu/variant2/pkg/app.(*App).execTest.func1(0xc0000cb500)>
        /home/runner/work/variant2/variant2/pkg/app/app.go:1037 +0xc2
testing.tRunner(0xc0000cb500, 0xc0005be790)
        /opt/hostedtoolcache/go/1.13.10/x64/src/testing/testing.go:909 +0xc9
created by testing.(*T).Run
        /opt/hostedtoolcache/go/1.13.10/x64/src/testing/testing.go:960 +0x350

  case "ng1" {
    concurrency = 0
    err = "delay of ${case.delayone} is less than ${case.delaytwo}"
    stdout = ""
    delayone = 0
    delaytwo = 1
  }

  run "test" {
    concurrency = case.concurrency
    delayone = case.delayone
    delaytwo = case.delaytwo
  }

err = "delay of 0 is less than 1"

➜ ./nbo deploy acme --tenants-dir=../tenants --dry-run --kubeconfig-path=~/.kube

INTERNAL: dry? false. kc-path? /dev/shm

TOP-LEVEL: dry? true. kc-path? ~/.kube

 (string)--- FAIL: deploy (0.06s)
    --- FAIL: deploy/ok (0.05s)
        app.go:1040: case "ok": assertion "out" failed: this expression must be true, but was false: run.res.stdout == case.out
            , where run.res.stdout=------------------------------------------------------------------------
            [CLIENT] Deploying terraform project: project1
            ------------------------------------------------------------------------
            terraform deploy project1 
            
            ------------------------------------------------------------------------
            [CLIENT] Deploying terraform project: project2
            ------------------------------------------------------------------------
            terraform deploy project2 
            
            ------------------------------------------------------------------------
            [CLIENT] Deploying helmfile project: project1
            ------------------------------------------------------------------------
            helmfile apply project1 
            
            ------------------------------------------------------------------------
            [CLIENT] Deploying helmfile project: project2
            ------------------------------------------------------------------------
            helmfile apply project2 
            
            ------------------------------------------------------------------------
            [CLIENT] Deploying terraform project: project3
            ------------------------------------------------------------------------
            terraform deploy project3 
            
             (string) case.out=------------------------------------------------------------------------
            [CLIENT] Deploying terraform project: project1
            ------------------------------------------------------------------------
            terraform deploy project1
            
            ------------------------------------------------------------------------
            [CLIENT] Deploying terraform project: project2
            ------------------------------------------------------------------------
            terraform deploy project2
            
            ------------------------------------------------------------------------
            [CLIENT] Deploying helmfile project: project1
            ------------------------------------------------------------------------
            helmfile apply project1
            
            ------------------------------------------------------------------------
            [CLIENT] Deploying helmfile project: project2
            ------------------------------------------------------------------------
            helmfile apply project2
            
            ------------------------------------------------------------------------
            [CLIENT] Deploying terraform project: project3
            ------------------------------------------------------------------------
            terraform deploy project3
             (string)
FAIL
Error: test exited with code 1

  26:       aws --profile ${var.namespace}-${var.tenant}-helm eks update-kubeconfig --name=${var.namespace}-${var.tenant}-eks-cluster --region=${var.region} --kubeconfig=${var.kubeconfig-path}/kubecfg.${var.tenant}-helm

There is no variable named "var".

  config "state" {
    source job {
      name = "state"
      args = {
        tenant = param.tenant
      }
      key = "key"
      format = "text"
    }
  }

triggers:
  smoke-test:
    description: Smoke testing the CLI
    order:
      - job: terraform plan eks
        args:
          - -detailed-exitcode

panic: inconsistent map element types (cty.List(cty.String) then cty.String)

goroutine 1 [running]:
<http://github.com/zclconf/go-cty/cty.MapVal(0xc0009ea880|github.com/zclconf/go-cty/cty.MapVal(0xc0009ea880>, 0xc0009ea880, 0xc0009d20f8, 0x3, 0xc0009ea9b8)
        /home/runner/go/pkg/mod/github.com/zclconf/go-cty@v1.2.1/cty/value_init.go:207 +0x4b3
<http://github.com/mumoshu/variant2/pkg/app.goToCty(0x1767100|github.com/mumoshu/variant2/pkg/app.goToCty(0x1767100>, 0xc0004d38f0, 0x0, 0x0, 0x1, 0xc0009bb8e0, 0x0, 0x1)
        /home/runner/work/variant2/variant2/pkg/app/go_to_cty.go:28 +0x60e
<http://github.com/mumoshu/variant2/pkg/app.(*App).execMultiRun(0xc0000e3140|github.com/mumoshu/variant2/pkg/app.(*App).execMultiRun(0xc0000e3140>, 0xc000239580, 0xc000819280, 0xc0009eadf8, 0x16, 0xc0009d1160, 0x16)
        /home/runner/work/variant2/variant2/pkg/app/app.go:1214 +0x13f
<http://github.com/mumoshu/variant2/pkg/app.(*App).execJob(0xc0000e3140|github.com/mumoshu/variant2/pkg/app.(*App).execJob(0xc0000e3140>, 0xc000239580, 0xc0000bd997, 0x7, 0x0, 0x205fbc0, 0xc0006fc540, 0xc0000c7610, 0xc000577ea0, 0x2, ...)
        /home/runner/work/variant2/variant2/pkg/app/app.go:816 +0x246
<http://github.com/mumoshu/variant2/pkg/app.(*App).Job.func1(0x0|github.com/mumoshu/variant2/pkg/app.(*App).Job.func1(0x0>, 0x0, 0x0)
        /home/runner/work/variant2/variant2/pkg/app/app.go:644 +0x939
<http://github.com/mumoshu/variant2/pkg/app.(*App).Run(0xc0000e3140|github.com/mumoshu/variant2/pkg/app.(*App).Run(0xc0000e3140>, 0xc0000bd997, 0x7, 0xc00080adb0, 0xc00080ade0, 0xc00020b9e0, 0x1, 0x1, 0x0, 0x0, ...)
        /home/runner/work/variant2/variant2/pkg/app/app.go:513 +0xc3
<http://github.com/mumoshu/variant2.(*Runner).Cobra.func1(0xc00037d180|github.com/mumoshu/variant2.(*Runner).Cobra.func1(0xc00037d180>, 0xc00080acf0, 0x2, 0x3, 0x0, 0x0)
        /home/runner/work/variant2/variant2/variant.go:661 +0x114
<http://github.com/spf13/cobra.(*Command).execute(0xc00037d180|github.com/spf13/cobra.(*Command).execute(0xc00037d180>, 0xc00080ac00, 0x3, 0x3, 0xc00037d180, 0xc00080ac00)
        /home/runner/go/pkg/mod/github.com/spf13/cobra@v0.0.5/command.go:826 +0x460
<http://github.com/spf13/cobra.(*Command).ExecuteC(0xc0000e9b80|github.com/spf13/cobra.(*Command).ExecuteC(0xc0000e9b80>, 0x2034ba0, 0xc0000be010, 0x2034ba0)
        /home/runner/go/pkg/mod/github.com/spf13/cobra@v0.0.5/command.go:914 +0x2fb
<http://github.com/spf13/cobra.(*Command).Execute(...)|github.com/spf13/cobra.(*Command).Execute(...)>
        /home/runner/go/pkg/mod/github.com/spf13/cobra@v0.0.5/command.go:864
<http://github.com/mumoshu/variant2.(*Runner).Run(0xc0007c3040|github.com/mumoshu/variant2.(*Runner).Run(0xc0007c3040>, 0xc0000f8c90, 0x4, 0x4, 0xc00020bd78, 0x1, 0x1, 0x0, 0x0)
        /home/runner/work/variant2/variant2/variant.go:791 +0x2cc
<http://github.com/mumoshu/variant2.Main.Run(0x7ffe211094bb|github.com/mumoshu/variant2.Main.Run(0x7ffe211094bb>, 0x3, 0x0, 0x0, 0x0, 0x7ffe211094b4, 0xa, 0x2034ba0, 0xc0000be008, 0x2034ba0, ...)
        /home/runner/work/variant2/variant2/variant.go:396 +0x12d
main.main()
        /home/runner/work/variant2/variant2/pkg/cmd/main.go:13 +0xb8

    order:
      - job: terraform plan eks
        args: ""
      - job: helmfile diff teleport
        args: --selector chart=teleport-node

    order:
      - job: terraform plan eks
        # args: ""
      - job: helmfile diff teleport
        args: --selector chart=teleport-node

Error: Missing map element

  on ../cli/trigger.variant line 36:
  (source code not available)

This map does not have an element with the key "job".

Error: ../cli/trigger.variant:36,29-33: Missing map element; This map does not have an element with the key "job".