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/JSON: For application JSON configurations
AppConfig/Text: For application plain-text configurations

Example Functions:

vet-cel: Validate resources using CEL expressions
vet-placeholders: Ensure no placeholders exist
set-default-names: Set default names for resources
set-annotation: Set annotations on resources

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, give each with --function, written as on the cub function do command line with an argument that holds whitespace in quotes, and omit the function positional arguments. The FunctionInvocations list can also come from --from-stdin or --filename.

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 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 --annotation-key=cloned --annotation-value=true

  # Create an invocation that calls two functions, in order
  cub invocation create --space my-space stamp-and-name Kubernetes/YAML \
    --function set-default-names --function 'set-annotation cloned true'

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)
      --display-name string           friendly name for the entity, which need not be unique or URL-safe; an entity without one is shown by its slug
      --dry-run                       report what the command would write, and write nothing
      --filename string               Read the ConfigHub entity's fields, as YAML or JSON, from file, URL (https://), or stdin (-), as --from-stdin does; 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)
      --filter-unit string            filter, by slug or UUID, over Units selecting those to create from, with --from-backing-units
      --from-backing-units            create an Invocation from each ConfigHub/YAML Unit --where-unit, --filter-unit and --space select that describes one, in the Unit's space, with the Unit as its backing Unit
      --from-stdin                    Read the ConfigHub entity's fields, as YAML or JSON, from stdin; merged with command arguments on create, and merged with command arguments and existing entity on update. A field the entity does not have, or one only the server sets, is refused; cub <entity> explain lists the fields
      --function stringArray          function the invocation runs, as <function> [<argument>...], written as on the cub function do command line (repeatable, in the order they run). It takes the place of the function given as arguments, for an invocation of more than one function
  -h, --help                          help for create
      --hidden-reason string          hide the entity, giving the reason as a name such as Archived: lists and bulk operations leave it out unless --include-hidden names the reason (use '-' to clear, which shows the entity again)
      --include-hidden string[="*"]   Also select hidden entities, to list or to act on: those hidden for the given HiddenReasons, comma-separated, as in --include-hidden=BackingUnit, or for any reason when given no value or "*". ConfigHub/YAML Units, which hold the configuration of other entities, are hidden with the reason BackingUnit. A --where naming entities by Slug or ID selects them whether hidden or not
      --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> }}.
      --patch-existing                with --from-backing-units, patch an Invocation a selected Unit already backs with what the Unit holds that it has not taken yet, rather than report that the Unit backs it
      --permission strings            permission in format Action:UserIDOrUsername, Action:group:GroupSlugOrID for a group you belong to, or Action:serviceaccount:ServiceAccountSlugOrID (e.g., Manage:user@example.com, View:group:platform, View:serviceaccount:deploy-bot, can be repeated)
      --quiet                         No default output.
      --set stringArray               set a field of the Invocation by its path, as <path>=<value> (repeatable). A path is field names separated by dots; a list element is addressed as ?<key>=<value> or by position, as in Stages.?Name=prod.WhereSpace, and is added if it is not there. A list of plain values separates them with ';'; an object or a list of objects is given as YAML or JSON. A reference is given as it is elsewhere, by slug, <space>/<slug> or ID. With --patch, only a path with no list element in it
      --unset stringArray             clear a field of the Invocation by its path, or remove the list element the path ends at (repeatable)
      --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
      --where-unit string             where expression over Units selecting those to create from, with --from-backing-units
      --with-backing-units            give each Invocation the bulk operation writes a backing Unit if it has none: a ConfigHub/YAML Unit holding its configuration, kept in step with it
      --worker string                 worker to execute the invocation function

Options inherited from parent commands

      --component string   the Component of --variant, when that names the variant alone; --variant <component>/<variant> says the same in one flag
      --context string     The context to use for this command
      --debug              Debug output
      --space string       space to operate in, by slug or UUID. Omitted, a list or bulk operation spans the organization and a single entity is named as <space>/<slug>; "*" means the same as omitting it
      --variant string     variant to operate in, as <component>/<variant>, or as <variant> with --component: the space naming that Component whose Variant label is <variant>. The same scope as --space, named by what it is rather than by the space's slug; the two cannot be combined

cub invocation create