Error List

The following is a list of errors that may be encountered when writing v2 manifests.

Syntax Errors

Components section has incorrect syntax. In the example below, a YAML list is used where map should be used.

'application' should be mapping or null
application:
  - components:
      aaa: {}

Component ‘Foo’ has no value. If you want leave to it empty, use an empty map: {}

Null values are not allowed
application:
  components:
    Foo:

A non-unique key in a YAML map.

Duplicate key: 'components'
Expected either a component type or a child components declaration
application:
  components:
    Foo: {}
  components:
    Bar: {}

Missing “type” directive for the “c1” component.

Expected either a component type or a child components declaration
application:
  components:
    c1:
      interfaces: {}

Interfaces section format is wrong. It should contain interface definitions.

Expected mapping for component 'interfaces' section
application:
  components:
    c1:
      type: reference.Service
      interfaces: foo

Pins should be defined in an interface.

Expected mapping as interface value
application:
  components:
    c1:
      type: reference.Service
      interfaces:
        foo: [x, y]

Pins should be of certain types: publish/consume-signal, send/recieve-command, events or configuration.

pin type expected, but 'string' found
application:
  components:
    c1:
      type: reference.Service
      interfaces:
        iface:
          foo: string

Type workflow.MyInstance does not exist.

Component 'inst' has unknown type 'workflow.MyInstance'.
application:
   components:
     inst:
       type: workflow.MyInstance

General Validation Errors

Component 'vm' of type 'workflow.Service' does not supports dynamic interfaces.
application:
   components:
     vm:
       type: workflow.Service
       interfaces:
         shell:
             execute: receive-command()

Missing interface pin name. In the example below, consume-signal() should be a pin type; however, it is erroneously used as an interface body.

Expected mapping as interface value
application:
  bindings:
    - [sender,reciever]
  components:
    sender:
      type: cobalt.common.Constants
      interfaces:
        output:
          const: publish-signal(string)
      configuration:
        configuration.values:
          output.const: "42"

    reciever:
      type: reference.Service
      interfaces:
        input: consume-signal()

Mapping of interface of component that resides under a scaler is not allowed

Mapping from scaler is prohibited
application:
  interfaces:
    hello:
      world: bind(cluster.constants#hello.world)
  components:
    cluster:
      type: composite.Scaler
      components:
        constants:
          type: cobalt.common.Constants
          interfaces:
            hello:
              world: publish-signal(string)
          configuration:
            configuration.values:
              hello.world: "Hello, world!"

Unknown entries in commands metadata

Wrong identifiers in pin metadata: b, a
application:
  components:
    workflow:
      type: workflow.Instance
      interfaces:
        actions:
          calculate:
            type: receive-command(int a => int b)
            arguments:
              b:
                name: "B"
            results:
              a:
                name: "A"
      configuration:
        configuration.workflows:
          calculate:
            steps: []
            return:
              b: { value: 3 }

Check Dynamic Interfaces

Two underscores at the beginning of an interface name are reserved for system use.

Interface '__test' can not be defined on component 's', interfaces starting from two underscores are reserved.
application:
   components:
     s:
       type: reference.Service
       interfaces:
         __test: {}

Two underscores at the beginning of a pin name are reserved for system use.

Pin '__x' on interface 'test' can not be defined on component 's', pins starting from two underscores are reserved.
application:
   components:
     s:
       type: reference.Service
       interfaces:
         test:
           __x: publish-signal(string)

‘cobalt.common.Constants’ already has a static interface named ‘configuration’. You can set its values within configuration.values.

Interface 'configuration' can not be defined on component 's', because it conflicts with static interface of component type 'cobalt.common.Constants'.
application:
   components:
     s:
       type: cobalt.common.Constants
       interfaces:
         configuration:
           myValue: configuration(string)

You can not bind configuration pins to reference.service pins. Apply configuration to other components.

Component 's' of type 'reference.Service' does not supports configuration values.
application:
   components:
     s:
       type: reference.Service
       configuration:
            x.y: 42

Full interface mappings and single-peer mappings can not be mixed in a single declaration:

Declarations for interface mappings should have form bind(component#interface.*)
Pin mappings should have form bind(component#interface.pin)
Bad syntax for pin reference 'x'
Bad syntax for pin reference '*'
application:
  components:
    a:
      interfaces:
        output1:
          "*": bind(workflow#result.str)  # str is pin, not a wildcard
          "x": bind(workflow#result.*)  # x is pin mapping, not a wildcard
      components: {}
    b:
      interfaces:
        output2:
          "x": bind(workflow#result.*, workflow#result.str)  # pin mapping with mixed style
      components: {}
    c:
      interfaces:
        output3:
          "*": bind(workflow#result.*, workflow#result.str)  # * mapping with mixed style
      components: {}

Check Configuration

All Constants component declared pins should have defined “configuration.values”, and all “configuration.values keys” should have a corresponding pin of the correct type.

Component 'myapp': No value provided for declared pins: 'input.cmd'.
application:
  components:
    myapp:
      type: cobalt.common.Constants
      interfaces:
        input:
          cmd: publish-signal(string)

      configuration:
        configuration.values: {}

In the example below, the dash sign indicates a list instead of a map, which is what the platform expects.

Component 's': Configuration value 'configuration.values' should have type 'map<string,object>'.
application:
   components:
     s:
       type: cobalt.common.Constants
       configuration:
         configuration.values:
           - a: b

Mapped configuration values should be type-checked:

‘values.a’ could be set in ‘configuration.values’ section, not ‘configuration’

Component 's': Trying to set configuration value for non-configuration pin 'values.a' of type publish-signal(string).
application:
   components:
     s:
       type: cobalt.common.Constants
       configuration:
         configuration.values: {}
         values.a: 42
       interfaces:
         values:
           a: publish-signal(string)

Also, mappings should not override explicitly defined values and should not lead to same pin.

Component 'd': Specified configuration value 'configuration.values' is overriden from parent root component by mapping pin 'constants.values'.
Pin mapping 'constants.eValues2' on root component conflicts with pin mapping 'constants.eValues1' on root component.
Pin mapping 'configuration.values' on component 'f' conflicts with pin mapping 'constants.fgValues1' on root component.
Component 'i': Specified configuration value 'configuration.values' is overriden from parent root component by mapping pin 'iconstants.values'.
application:
  components:
    c:
      type: cobalt.common.Constants
      interfaces:
        foo:
          stringValue: publish-signal(string)
    d:
      type: cobalt.common.Constants
      interfaces:
        foo:
          stringValue: publish-signal(string)
      configuration:
        configuration.values:
          foo.stringValue: ok
    e:
      type: cobalt.common.Constants
      interfaces:
        foo:
          stringValue: publish-signal(string)
    f:
      interfaces:
        configuration:
          values: bind(g#configuration.values)
      components:
        g:
          type: cobalt.common.Constants
          interfaces:
            foo:
              stringValue: publish-signal(string)
    i:
      type: cobalt.common.Constants
      interfaces:
        foo:
          stringValue: publish-signal(string)
      configuration:
        configuration.values:
          foo.stringValue: ok
  interfaces:
    constants:
      values: bind(d#configuration.values, c#configuration.values)
      eValues1: bind(e#configuration.values)
      eValues2: bind(e#configuration.values)
      fgValues1: bind(f.g#configuration.values)
      fgValues2: bind(f#configuration.values)
    iconstants:
      '*': bind(i#configuration.*)
  configuration:
    constants.values:
      foo.stringValue: "hello"
    constants.eValues1:
      foo.stringValue: "hello"
    constants.eValues2:
      foo.stringValue: "hello"
    constants.fgValues1:
      foo.stringValue: "hello"
    constants.fgValues2:
      foo.stringValue: "hello"
    iconstants.values:
      foo.stringValue: "hello"

Top-level configuration and interfaces belong to the “root component”:

Root component: Configuration value 'configuration.values' should have type 'map<string,object>'.
application:
  interfaces:
    configuration:
      values: bind(s#configuration.values)
  configuration:
    configuration.values:
      - a: b
  components:
    s:
      type: cobalt.common.Constants

Constants component configuration should go to the configuration.values section.

Component 's': Trying to set unknown configuration value 'configuration.myValues'.
Component 's': Configuration key 'otherValue' is not a valid pin id. Pin id should consist of interface and pin name, separated by dot.
application:
   components:
     s:
       type: cobalt.common.Constants
       configuration:
         configuration.myValues:
           - a: b
         otherValue: 42
Component 'a' of type 'reference.Service' can not be a composite and can not contain 'components' section.
application:
   components:
     a:
       type: reference.Service
       components: {}

It is OK not to define values for configuration pins in inner components if they are mapped through to the root component. These are correct manifests:

application:
  components:
    constants:
      type: cobalt.common.Constants
      # define configuration directly in the manifest
      configuration:
        configuration.values: {}
application:
  interfaces:
    # expose configuration through a mapping on the root component
    cfg:
      cfg: bind(constants#configuration.values)
  components:
    constants:
      type: cobalt.common.Constants

This manifest, on the other hand, is invalid, because configuration.values pin is neither configured directly nor passed through via a mapping:

Component 'constants': Required configuration value 'configuration.values' is neither set nor mapped to the root component.
application:
  components:
    constants:
      type: cobalt.common.Constants

Bindings

Bound interfaces should have pins with matching names and complimentary types.

Can not bind components 'sender' and 'reciever' because they have no matched interfaces.
application:
  bindings:
    - [sender,reciever]
  components:
    sender:
      type: cobalt.common.Constants
      interfaces:
        output:
          const: publish-signal(string)
      configuration:
        configuration.values:
          output.const: "42"

    reciever:
      type: reference.Service
      interfaces:
        input:
          val: consume-signal(string)

A component of type ‘reference.Service’ should be created and bound to ‘inst’.

Component 'serv' interface 'vault' is marked as required, but it is not bound.
application:
   components:
     serv:
       type: reference.Submodule
       interfaces:
         vault:
           get-keypair: send-command(string id => object privateKey)
       configuration:
         __locator.application-id: "Secure Vault 2.0"
       required:
         - vault

A binding should not have the same component on both sides.

Can not bind component 'serv' to itself.
application:
   components:
     serv:
       type: reference.Service
       interfaces:
          compute:
            get-keypair: receive-command(string id => object privateKey)
   bindings:
    - [serv, serv]

Attempting to bind to a component that doesn’t exist. Component ‘inst’ needs corresponding interface.

Component 'serv' is not defined in manifest.
application:
   components:
     inst:
       type: workflow.Instance
       configuration:
         configuration.workflows:
           launch: {steps: []}
           destroy: {steps: []}
   bindings:
    - [inst, serv]

Composites define their interfaces using a bind() directive, which contains a reference to a child component’s pin. If the referenced pin is in a required interface, then the composite interface is also required.

Composite 'wrapper' interface is required, but it is not bound. Composite interfaces are required, if they are mapped using bind() directive to other required interface.
application:
  components:
    wrapper:
      interfaces:
        executor:
          execute-workflow: bind(serv#vault.get-keypair)
      components:
        serv:
          type: reference.Submodule
          interfaces:
            vault:
              get-keypair: send-command(string id => object privateKey)
          configuration:
            __locator.application-id: "Secure Vault 2.0"
          required:
            - vault
Component 'inst' has unknown type 'workflow.MyInstance'.
application:
   components:
     inst:
       type: workflow.MyInstance

Component-specific Errors

cobalt.common.Constants

Component 'const' of type 'cobalt.common.Constants' does not supports events, so dynamic interface 'network' should not contain pins of type publish-event, consume-event
application:
   components:
     const:
       type: cobalt.common.Constants
       interfaces:
          network:
            has-multicast: publish-event(unit)
       configuration:
         configuration.values: {}
Component 'const': Only publish-signal pins are supported, but found 'input.cmd' pin of type consume-signal(string)
application:
  components:
    const:
      type: cobalt.common.Constants
      interfaces:
        input:
          cmd: consume-signal(string)

      configuration:
        configuration.values: {}

Quote a digital value if a component expects a string.

Component 'const': Value for pin 'network.subnet' has wrong type, expected string
application:
   components:
     const:
       type: cobalt.common.Constants
       interfaces:
          network:
            subnet: publish-signal(string)
       configuration:
         configuration.values:
           network.subnet: 42

Constants should be declared.

Component 'const': No interface or pin declared for configuration values: 'network.mask'.
Component 'const': No value provided for declared pins: 'network.prefixLength'.
application:
   components:
     const:
       type: cobalt.common.Constants
       interfaces:
          network:
            subnet: publish-signal(string)
            prefixLength: publish-signal(int)
       configuration:
         configuration.values:
           network.subnet: "192.168.0.0"
           network.mask:   "255.255.255.0"

workflow.Service

Component 'wfService': /quantity: condition "min/max" failed: incorrect value type "string" ("int" or "double" expected)
Component 'wfService': /quantity: condition "type" failed: incorrect value type "string" ("int" expected)
Component 'wfService': Step 'provisionVms' does not have parameter 'ohThisParameterNotExists'
Component 'wfService': Expected policy name in format stepName.parameterName, got 'myPolicy'
application:
  components:
    wfService:
      type: workflow.Service
      configuration:
        configuration.policies:
          a.b: 123
          c.d: 456
          provisionVms.ohThisParameterNotExists: really!
          provisionVms.quantity: 4 vms please
          myPolicy: 42

workflow.Instance

Service reference should contain at least one interface

reference.Service without interfaces is prohibited
application:
  components:
    srv:
      type: reference.Service

Injected-manifest Errors

Incorrect workflow declaration

Component 'workflow': destroy: unexpected element type "int" ("map" expected)
application:
  components:

    workflow:
      type: workflow.Instance
      configuration:
        configuration.triggers: {}
        configuration.workflows:
          launch:
            steps: []
          destroy: 42

    genesis:
      type: reference.Service
      interfaces:
        executor:
          execute-workflow: receive-command(object request => object status => object status)

  bindings:
    - [workflow, genesis]

Dynamic-interface Errors

Component 'workflow': Interface 'input' can contain only configuration pins, pin 'b' of type 'consume-signal(int)' can be defined in any interface of a workflow.Instance component except for 'input', 'result', or 'actions'.
Component 'workflow': Interface 'result' should contain only publish-signal pins, pin 'y' of type 'publish-event(string)' cannot be defined on a workflow.Instance component.
application:
  components:

    workflow:
      type: workflow.Instance
      interfaces:
        input:
          a: configuration(string)
          b: consume-signal(int)
        result:
          k: publish-signal(string)
          y: publish-event(string)
      configuration:
        configuration.triggers: {}
        configuration.workflows:
          launch:
            steps: []
          destroy:
            steps: []
        input.a: myValue1

    genesis:
      type: reference.Service
      interfaces:
        executor:
          execute-workflow: receive-command(object request => object status => object status)

  bindings:
    - [workflow, genesis]
Component 'workflow': Interface 'myService' can contain only consume-signal or send-command pins, pin 'c' of type 'consume-event(map<string,object>)' cannot be defined on a workflow.Instance component.
Component 'workflow': Interface 'actions' can contain only send-command pins, pin 'updated' of type 'publish-event(map<string,object>)' cannot be defined on a workflow.Instance component.
application:
  components:

    workflow:
      type: workflow.Instance
      interfaces:
        input:
          a: configuration(string)
          b: configuration(int)
        myService:
          c: consume-event(map<string,object>)
        actions:
          update: receive-command()
          do-something: receive-command(string t => string myResult)
          updated: publish-event(map<string,object>)
        result:
          k: publish-signal(string)
      configuration:
        configuration.triggers:
          input.a: reload
          actions.update: reload
          reload: reload
        configuration.workflows:
          launch:
            steps: []
          do-something:
            parameters:
              s:
                type: string
              t:
                type: int
            steps: []
            return:
              someData:
                value: 42
          destroy:
            steps: []
        input.a: myValue1

    genesis:
      type: reference.Service
      interfaces:
        executor:
          execute-workflow: receive-command(object request => object status => object status)

  bindings:
    - [workflow, genesis]
Component 'workflow': workflow.Instance defines a signal 'k', which is not found among the launch workflow return values.
Component 'workflow': Every workflow.Instance command must have a matching workflow. Unrecognized command: 'update'. Available workflows are: 'do-something'.
Component 'workflow': Workflow 'do-something' parameter 's' is not defined as a parameter in the corresponding command, input configuration/signal, or provided with a default value.
application:
  components:

    workflow:
      type: workflow.Instance
      interfaces:
        input:
          a: configuration(string)
          b: configuration(int)
        myService:
          c: consume-signal(map<string,object>)
        actions:
          update: receive-command()
          do-something: receive-command(string t => string myResult)
        result:
          k: publish-signal(string)
      configuration:
        configuration.workflows:
          launch:
            parameters:
              a:
                type: string
            steps: []
          do-something:
            parameters:
              s:
                type: string
              t:
                type: int
            steps: []
            return:
              someData:
                value: 42
          destroy:
            steps: []
        input.a: myValue1
        input.b: 42

    genesis:
      type: reference.Service
      interfaces:
        executor:
          execute-workflow: receive-command(object request => object status => object status)

  bindings:
    - [workflow, genesis]

Triggers

Component 'workflow': Key in triggers map should be pin ids, got 'onReload'. Correct pin id consists of interface and pin name, separated by dot.
Component 'workflow': Unsuitable input pin 'actions.update'. Only input and properties pins (configuration and consume-signal) can be used for triggers.
Component 'workflow': Can not find workflow 'reload' to execute on change of pin 'input.x'. Declared workflow names are: launch, destroy.
application:
  components:

    workflow:
      type: workflow.Instance
      interfaces:
        input:
          x: configuration(int)
      configuration:
        input.x: 42
        configuration.triggers:
          input.x: reload
          actions.update: reload
          onReload: reload
        configuration.workflows:
          launch:
            steps: []
          destroy:
            steps: []

    genesis:
      type: reference.Service
      interfaces:
        executor:
          execute-workflow: receive-command(object request => object status => object status)

  bindings:
    - [workflow, genesis]

Propagate Status

Component 'workflow': Workflow 'upgrade' is not defined.
Component 'workflow': Expected list of exposed statuses for workflow 'update'. Possible statuses are: progress, result.
Component 'workflow': propagateStatus elements should be either workflow names or maps from workflow name to list of status names.
application:
  components:

    workflow:
      type: workflow.Instance
      configuration:
        configuration.propagateStatus:
          - upgrade
          - update: [success]
          - restart: []
            update: []
        configuration.workflows:
          restart:
            steps: []
          update:
            steps: []

    genesis:
      type: reference.Service
      interfaces:
        executor:
          execute-workflow: receive-command(object request => object status => object status)

  bindings:
    - [workflow, genesis]