score-k8s resources provisioners

score-k8s init --provisioners https://example.com/provisioner-A.yaml --provisionerss https://example.com/provisioner-B.yaml

- uri: <provisioner uri>
  type: <resource type>
  class: <optional resource class>
  id: <optional resource id>
  description: <optional description>

type Data struct {
    Uid      string
    Type     string
    Class    string
    Id       string
    Params   map[string]interface{}
    Metadata map[string]interface{}
    Init   map[string]interface{}
    State  map[string]interface{}
    Shared map[string]interface{}
    WorkloadServices map[string]NetworkService
}

- uri: template://example-provisioners/example-provisioner
  
  # (Required) Which resource type to match
  type: example-provisioner-resource
  
  description: Example provisioner that runs a template.
  
  # (Optional) Which 'class' of the resource. Null will match any class, a non-empty value like 'default' will match
  # only resources of that class.
  class: null
  
  # (Optional) The exact resource id to match. Null will match any resource, a non-empty value will only match
  # the resource with exact same id.
  id: null
  
  # (Optional) The init template sets the initial context values on each provision request. This is a text template
  # that must evaluate to a YAML/JSON key-value map.
  init: |
    key: value
    # sprig functions are also supported
    key2: {{ print "value" | upper }}
    # other attributes are available such as Type, Class, Id, Uid, Guid.
    my-uid: "{{ .Uid }}#{{ .Guid }}"    
  
  # (Optional) The state template gets evaluated next and sets the internal state of this resource based on the previous
  # state and the init context. Like init, this evaluates to a YAML/JSON object. This is the template that allows
  # state to be stored between each generate call.
  state: |
    stateKey: {{ .Init.key }} # will copy the value from init
    stateKey2: {{ default 0 .State.stateKey2 | add 1 }} # will increment on each provision attempt    
  
  # (Optional) The shared state template is like state, but is a key-value structure shared between all resources.
  # This can be used to coordinate shared resources and state between resources of the same or related types.
  shared: |
    section:
      key: {{ .Shared.foo }}    
  
  # (Optional) The outputs template gets evaluated last and translates into the outputs available as placeholder
  # references like ${resources.my-resource.key}.
  outputs: |
    plaintext: my-value
    nested:
      example: thing
    # Instead of returning secret outputs as plaintext. They can be embedded as reference to Kubernetes Secrets. When
    # these are detected, they can be used in environment variables or file contents securely. The format is 
    # 🔐💬<secret name>_<secret key name>💬🔐. For example, the next line refers to a secret created in the manifests.
    secret-reference: 🔐💬secret-{{ .Guid }}_password💬🔐
    # A template function also exists for generating these in the template provisioner.
    secret-reference-alt: {{ encodeSecretRef (printf "secret-%s" .Guid) "password" }}    
  
  expected_outputs:
    - plaintext
    - nested
    - secret-reference
    - secret-reference-alt
  
  # (Optional) The manifests template gets evaluated as a list of Kubernetes object manifests to be added to the output.
  manifests: |
    - apiVersion: v1
      kind: ConfigMap
      metadata:
        name: cfg-{{ .Guid }}
        annotations:
          k8s.score.dev/source-workload: {{ .SourceWorkload }}
          k8s.score.dev/resource-uid: {{ .Uid }}
          k8s.score.dev/resource-guid: {{ .Guid }}
      data:
        key: {{ .Init.key }}
    - apiVersion: v1
      kind: Secret
      metadata:
        name: secret-{{ .Guid }}
        annotations:
          k8s.score.dev/source-workload: {{ .SourceWorkload }}
          k8s.score.dev/resource-uid: {{ .Uid }}
          k8s.score.dev/resource-guid: {{ .Guid }}
        labels:
          app.kubernetes.io/managed-by: score-k8s
          app.kubernetes.io/name: {{ .State.service }}
          app.kubernetes.io/instance: {{ .State.service }}
      data:
        password: {{ b64enc "my-secret-password" }}    

- uri: "cmd://python"
  args: ["-c", "print({\"resource_outputs\":{}})"]

- uri: cmd://bash#example-provisioner
  
  type: example-provisioner-resource
  
  description: Example provisioner that runs a bash script.
  
  class: default
  
  id: specific
  
  # (Optional) additional args that the binary gets run with
  # If any of the args are '<mode>' it will be replaced with "provision"
  args: ["-c", "echo '{\"resource_outputs\":{\"key\":\"value\",\"secret\":\"🔐💬mysecret_mykey💬🔐\"},\"manifests\":[]}'"]
  
  expected_outputs:
    - key
    - secret