cub invocation create

Create a new invocation or bulk create invocations

Synopsis

Create a new invocation or bulk create multiple invocations by cloning existing ones.

SINGLE INVOCATION CREATION:

Create a new invocation to define a function invocation.

Toolchain Types:

Kubernetes/YAML: For Kubernetes YAML configurations
ConfigHub/YAML: For ConfigHub YAML configurations
AppConfig/Properties: For application Java Properties configurations
AppConfig/YAML: For application YAML configurations
AppConfig/TOML: For application TOML configurations
AppConfig/INI: For application INI configurations
AppConfig/Env: For application Env configurations
AppConfig/YAML: For application YAML configurations
AppConfig/JSON: For application JSON configurations

Example Functions:

vet-cel: Validate resources using CEL expressions
vet-approvedby: Check if resource is approved
vet-placeholders: Ensure no placeholders exist
set-default-names: Set default names for resources
set-annotation: Set annotations on resources
ensure-context: Ensure context annotations are present

Function arguments can be provided as positional arguments or as named arguments using --argumentname=value syntax. Once a named argument is used, all subsequent arguments must be named. Use "--" to separate command flags from function arguments when using named function arguments.

An Invocation can call several functions, which are executed in the order they are listed. The positional form creates an Invocation that calls one function; to create one that calls several, supply the FunctionInvocations list with --from-stdin or --filename and omit the function positional arguments.

BULK INVOCATION CREATION:

When no positional arguments are provided, bulk create mode is activated. This mode clones existing invocations based on filters and creates multiple new invocations with optional modifications.

Single Invocation Examples:

  # Create an invocation to validate replicas > 1 for Deployments
  cub invocation create --space my-space -o json replicated Kubernetes/YAML vet-cel 'r.kind != "Deployment" || r.spec.replicas > 1'

  # Create an invocation to enforce low resource usage (replicas < 10)
  cub invocation create --space my-space -o json lowcost Kubernetes/YAML vet-cel 'r.kind != "Deployment" || r.spec.replicas < 10'

  # Create an invocation to ensure no placeholders exist in resources
  cub invocation create --space my-space -o json complete Kubernetes/YAML vet-placeholders

  # Create an invocation requiring approval before applying changes
  cub invocation create --space my-space -o json require-approval Kubernetes/YAML vet-approvedby 1

  # Create an invocation to add a "cloned=true" annotation
  cub invocation create --space my-space -o json stamp Kubernetes/YAML set-annotation cloned true

  # Using named arguments for clarity (note the "--" separator)
  cub invocation create --space my-space -o json stamp Kubernetes/YAML -- set-annotation --key=cloned --value=true

  # Create an invocation that calls several functions in order
  echo '{"FunctionInvocations": [
           {"FunctionName": "set-default-names"},
           {"FunctionName": "set-annotation", "Arguments": [{"Value": "cloned"}, {"Value": "true"}]}
         ]}' | cub invocation create --space my-space --from-stdin stamp-and-name Kubernetes/YAML

Bulk Create Examples:

  # Clone all invocations matching a pattern with name prefixes
  cub invocation create --where "FunctionInvocations.*.FunctionName = 'vet-cel'" --name-prefix dev-,staging- --dest-space dev-space

  # Clone specific invocations to multiple spaces
  cub invocation create --invocation my-invocation --dest-space dev-space,staging-space

  # Clone invocations using a where expression for destination spaces
  cub invocation create --where "ToolchainType = 'Kubernetes/YAML'" --where-space "Labels.Environment IN ('dev', 'staging')"

  # Clone invocations with modifications via JSON patch
  echo '{"FunctionInvocations": [{"FunctionName": "vet-placeholders"}]}' | cub invocation create --where "FunctionInvocations.*.FunctionName = 'vet-cel'" --name-prefix v2- --from-stdin

cub invocation create [<slug> <toolchain type> [<function> [<arg1> ...]]] [flags]

Options

      --allow-exists             Allow creation of resources that already exist
      --annotation strings       annotations in key=value format; can separate by commas and/or use multiple instances of the flag
      --delete-gate strings      delete gates in key[=true] format; can separate by commas and/or use multiple instances of the flag
      --dest-space strings       destination spaces for bulk create (can be repeated or comma-separated)
      --filename string          Read the ConfigHub entity JSON from file, URL (https://), or stdin (-); mutually exclusive with --from-stdin
      --filter string            Filter entity to apply to the list. Specify as 'space/filter' for cross-space filters or just 'filter' for current space. Supports both slugs and UUIDs. The filter will be combined with any --where clause using AND logic. Examples: "production-filters/security-check", "my-filter-uuid", "validation-rules"
      --filter-space string      filter entity containing WHERE expression to select destination spaces for bulk create (slug or UUID)
      --from-stdin               Read the ConfigHub entity JSON (e.g., retrieved with cub <entity> get --quiet --json) from stdin; merged with command arguments on create, and merged with command arguments and existing entity on update
  -h, --help                     help for create
      --invocation strings       target specific invocations by slug or UUID for bulk create (can be repeated or comma-separated)
      --label strings            labels in key=value format; can separate by commas and/or use multiple instances of the flag
      --name-pattern string      a pattern string for name generation of clones, prefix 'template:' to use a Go template with .SourceEntity to access the original Invocation and .Labels to access variant labels, example: 'template:{{.SourceEntitySlug}}-{{.Labels.env}}'
      --name-prefix strings      name prefixes for bulk create (can be repeated or comma-separated)
  -o, --output string            Output format. One of: json, yaml, name, wide, mutations, jq=<expr>, yq=<expr>, custom-columns=<spec>
      --parameter stringArray    declare a parameter as name[:datatype[:required]] (datatype defaults to string, required defaults to true; can be repeated). Reference declared parameters from templated argument values via {{ .Params.<name> }}.
      --quiet                    No default output.
      --variant-labels strings   labels for bulk create in the format of key1=value1|value2,key2=value1|value2|value3
      --verbose                  Detailed output, additive with default output
      --where string             Filter expression using SQL-inspired syntax. Supports conjunctions with AND. String operators: =, !=, <, >, <=, >=, LIKE, NOT LIKE, ILIKE, ~~, !~~, ~, ~*, !~, !~*. Pattern matching with LIKE/ILIKE uses % and _ wildcards. Regex operators (~, ~*, !~, !~*) support POSIX regular expressions. A related entity is referenced by prefix, as in "UpstreamUnit.Slug = 'base'"; when the reference names a list, a * segment matches any element, as in "FromLink.*.Slug = 'upgrade-app'". Examples: "Slug LIKE 'app-%'", "DisplayName ILIKE '%backend%'", "Slug ~ '^[a-z]+-[0-9]+$'"
      --where-space string       where expression to select destination spaces for bulk create
      --worker string            worker to execute the invocation function

Options inherited from parent commands

      --context string   The context to use for this command
      --debug            Debug output
      --space string     space ID to perform command on

cub invocation create