opentf-toolkit-nightly 0.62.0.dev1347__py3-none-any.whl → 0.62.0.dev1370__py3-none-any.whl

opentf/commons/__init__.py

@@ -27,8 +27,6 @@ import jwt
 
 from flask import Flask, current_app, make_response, request, g, Response
 
-from toposort import toposort, CircularDependencyError
-
 from .auth import (
     initialize_authn_authz,
     get_user_accessible_namespaces,
@@ -220,6 +218,10 @@ def _get_contextparameter_spec(app: Flask, name: str) -> Optional[Dict[str, Any]
     parameters = app.config[PARAMETERS_KEY]
     try:
         spec = get_named(name, parameters)
+        if spec.get('type') == 'int':
+            spec['type'] = 'number'
+        if spec.get('type') == 'bool':
+            spec['type'] = 'boolean'
     except ValueError:
         spec = None
     return spec
@@ -429,7 +431,7 @@ def make_app(
 
     `CONFIG` is a dictionary, the complete config file.  `CONTEXT` is a
     subset of `CONFIG`, the current entry in `CONFIG['context']`.  It is
-    also a dictionary.  `DESCRIPTOR` is the service descriptor.
+    also a dictionary.  `DESCRIPTOR` is the service descriptors.
 
     # Raised Exception
 
@@ -466,6 +468,12 @@ def make_app(
     app.config['DESCRIPTOR'] = (
         descriptor if isinstance(descriptor, list) else [descriptor]
     )
+    try:
+        validate_descriptors(app.config['DESCRIPTOR'])
+    except ValueError as err:
+        app.logger.error('Invalid descriptor: %s', err)
+        sys.exit(2)
+
     app.route('/health', methods=['GET'])(lambda: 'OK')
     app.before_request(_make_authenticator(context))
     app.after_request(_add_securityheaders)
@@ -566,11 +574,10 @@ def get_context_parameter(
         )
 
     if spec:
-        if spec.get('type') == 'int':
-            try:
-                val = int(val)
-            except ValueError as err:
-                _fatal(f'Context parameter "{name}" not an integer: {err}.')
+        try:
+            val = validate_value(spec, val)
+        except ValueError as err:
+            _fatal(f'Context parameter "{name}": {err}')
         desc = spec['descriptiveName'][0].upper() + spec['descriptiveName'][1:]
         if 'minValue' in spec and val < spec['minValue']:
             _fatal(f'{desc} must be greater than {spec["minValue"]-1}.')
@@ -746,173 +753,3 @@ def annotate_response(
         if seen := {k for k in processed if request.args.get(k) is not None}:
             response.headers['X-Processed-Query'] = ','.join(seen)
     return response
-
-
-########################################################################
-# Pipelines Helpers
-
-
-def validate_pipeline(
-    workflow: Dict[str, Any],
-) -> Tuple[bool, Union[str, List[List[str]]]]:
-    """Validate workflow jobs, looking for circular dependencies.
-
-    # Required parameters
-
-    - workflow: a dictionary
-
-    # Returned value
-
-    A (`bool`, extra) pair.
-
-    If there is a dependency on an non-existing job, returns
-    `(False, description (a string))`.
-
-    If there are circular dependencies in the workflow jobs, returns
-    `(False, description (a string))`.
-
-    If there are no circular dependencies, returns `(True, jobs)` where
-    `jobs` is an ordered list of job names lists.  Each item in the
-    returned list is a set of jobs that can run in parallel.
-    """
-    try:
-        jobs = {}
-        for job_name, job_definition in workflow['jobs'].items():
-            if needs := job_definition.get('needs'):
-                if isinstance(needs, list):
-                    jobs[job_name] = set(needs)
-                else:
-                    jobs[job_name] = {needs}
-            else:
-                jobs[job_name] = set()
-        for src, dependencies in jobs.items():
-            for dep in dependencies:
-                if dep not in jobs:
-                    return (
-                        False,
-                        f"Job '{src}' has a dependency on job '{dep}' which does not exist.",
-                    )
-
-        return True, [list(items) for items in toposort(jobs)]
-    except CircularDependencyError as err:
-        return False, str(err)
-
-
-def _normalize_inputs(inputs: Dict[str, Any]) -> None:
-    """Normalize inputs.
-
-    The 'normalized' form for inputs is with `-` separators, not `_`.
-
-    Non-normalized inputs are removed from the dictionary.
-
-    # Raised exceptions
-
-    A _ValueError_ exception is raised if an input is provided twice, in
-    a normalized as well as a non-normalized form.
-    """
-    for key in inputs.copy():
-        if '_' in key:
-            normalized = key.replace('_', '-')
-            if normalized in inputs:
-                raise ValueError(
-                    f'Both "{key}" and "{normalized}" specified in inputs.'
-                )
-            inputs[normalized] = inputs.pop(key)
-
-
-def _set_default(inputs: Dict[str, Any], key: str, definition: Dict[str, Any]) -> None:
-    if (default := definition.get('default')) is not None:
-        inputs[key] = default
-    elif type_ := definition.get('type'):
-        if type_ == 'string':
-            inputs[key] = ''
-        elif type_ == 'number':
-            inputs[key] = 0
-        elif type_ == 'boolean':
-            inputs[key] = False
-
-
-def validate_inputs(
-    declaration: Dict[str, Dict[str, Any]],
-    inputs: Dict[str, Any],
-    additional_inputs: bool = False,
-    normalize: bool = True,
-) -> None:
-    """Validate inputs.
-
-    Default values are filled in `inputs` as appropriate.
-
-    Input names are normalized to use hyphens instead of underscores
-    by default (declaration is expected to be normalized).
-
-    If `normalize` is set, non-normalized inputs are removed from the
-    dictionary.
-
-    Choices values are validated.
-
-    Types are enforced if declared as `boolean`, `number`, or `string`.
-    Conversion is performed if needed.
-
-    # Required parameters
-
-    - declaration: a dictionary
-    - inputs: a dictionary
-
-    # Optional parameters
-
-    - additional_inputs: a boolean (False by default)
-    - normalize: a boolean (True by default)
-
-    # Raised exceptions
-
-    A _ValueError_ exception is raised if inputs do not match
-    declaration.
-    """
-    if normalize and not any(key.startswith('{') for key in declaration):
-        _normalize_inputs(inputs)
-
-    for key, definition in declaration.items():
-        if key.startswith('{'):
-            continue
-        if key not in inputs:
-            if definition.get('required', False):
-                raise ValueError(f'Mandatory input "{key}" not provided.')
-            _set_default(inputs, key, definition)
-            continue
-        val = inputs.get(key)
-        type_ = definition.get('type')
-        if type_ == 'choice':
-            if val not in definition['options']:
-                allowed = '", "'.join(sorted(definition['options']))
-                raise ValueError(
-                    f'Invalid value "{val}" for input "{key}".  Allowed values: "{allowed}".'
-                )
-        elif type_ == 'boolean' and not isinstance(val, bool):
-            if isinstance(val, str) and val.lower() in ('true', 'false'):
-                inputs[key] = val.lower() == 'true'
-                continue
-            raise ValueError(
-                f'Invalid value "{val}" for input "{key}".  Allowed values: "true", "false".'
-            )
-        elif type_ == 'number' and not isinstance(val, (int, float)):
-            try:
-                inputs[key] = int(val)
-            except ValueError:
-                try:
-                    inputs[key] = float(val)
-                except ValueError:
-                    raise ValueError(
-                        f'Invalid value "{val}" for input "{key}".  Expected a number.'
-                    )
-        elif type_ == 'string' and not isinstance(val, str):
-            inputs[key] = str(val)
-
-    if additional_inputs:
-        return
-
-    if unexpected := set(inputs) - set(declaration):
-        allowed = '", "'.join(sorted(declaration))
-        unexpected = '", "'.join(sorted(unexpected))
-        raise ValueError(
-            f'Unexpected inputs "{unexpected}" found.  Allowed inputs: "{allowed}".'
-        )

opentf/commons/config.py

@@ -220,7 +220,7 @@ def read_config(
     else:
         configfile = altconfig or configfile
         try:
-            config = read_and_validate(configfile, schema or SERVICECONFIG)
+            config = read_and_validate(schema or SERVICECONFIG, configfile)
         except (ValueError, OSError) as err:
             raise ConfigError(f'Could not read configfile "{configfile}": {err}.')
 

opentf/commons/schemas.py

@@ -12,17 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Helpers for the OpenTestFactory schemas."""
+"""Helpers for the OpenTestFactory schemas and validation."""
 
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
 
 import json
 import logging
 import os
 
 from jsonschema import Draft201909Validator, ValidationError
+from toposort import toposort, CircularDependencyError
 from yaml import safe_load
 
+
 import opentf.schemas
 
 
@@ -65,6 +67,8 @@ RETENTION_POLICY = 'opentestfactory.org/v1alpha1/RetentionPolicy'
 TRACKER_PUBLISHER = 'opentestfactory.org/v1alpha1/TrackerPublisher'
 INSIGHT_COLLECTOR = 'opentestfactory.org/v1alpha1/InsightCollector'
 
+PLUGIN_DESCRIPTOR = 'config.opentestfactory.org/v1/Descriptor'
+
 
 ########################################################################
 # JSON Schema Helpers
@@ -133,17 +137,17 @@ def validate_schema(
     return True, None
 
 
-def read_and_validate(filename: str, schema: str) -> Dict[str, Any]:
+def read_and_validate(schema: str, filename: str) -> Dict[str, Any]:
     """Read and validate a JSON or YAML file.
 
     # Required parameters
 
+    - schema: a string, the schema name (its kind)
     - filename: a string, the file name
-    - schema: a string, the schema to validate the file content
 
     # Returned value
 
-    A dictionary, the definition.
+    A dictionary, the valid content.
 
     # Raised exceptions
 
@@ -161,3 +165,290 @@ def read_and_validate(filename: str, schema: str) -> Dict[str, Any]:
     if not valid:
         raise ValueError(f'Invalid content: {extra}.')
     return config
+
+
+########################################################################
+# Pipelines Helpers
+
+
+def validate_pipeline(
+    workflow: Dict[str, Any],
+) -> Tuple[bool, Union[str, List[List[str]]]]:
+    """Validate workflow jobs, looking for circular dependencies.
+
+    # Required parameters
+
+    - workflow: a dictionary
+
+    # Returned value
+
+    A (`bool`, extra) pair.
+
+    If there is a dependency on an non-existing job, returns
+    `(False, description (a string))`.
+
+    If there are circular dependencies in the workflow jobs, returns
+    `(False, description (a string))`.
+
+    If there are no circular dependencies, returns `(True, jobs)` where
+    `jobs` is an ordered list of job names lists.  Each item in the
+    returned list is a set of jobs that can run in parallel.
+    """
+    jobs = {}
+    for job_name, job_definition in workflow['jobs'].items():
+        if needs := job_definition.get('needs'):
+            if isinstance(needs, list):
+                jobs[job_name] = set(needs)
+            else:
+                jobs[job_name] = {needs}
+        else:
+            jobs[job_name] = set()
+    for src, dependencies in jobs.items():
+        for dep in dependencies:
+            if dep not in jobs:
+                return (
+                    False,
+                    f'Job "{src}" has a dependency on job "{dep}" which does not exist.',
+                )
+    try:
+        return True, [list(items) for items in toposort(jobs)]
+    except CircularDependencyError as err:
+        return False, str(err)
+
+
+def validate_workflow(workflow: Dict[str, Any]) -> List[List[str]]:
+    """Validate workflow.
+
+    # Required parameters
+
+    - workflow: a dictionary
+
+    # Returned value
+
+    An ordered list of job names lists.  Each item in the returned list
+    is a set of jobs that can run in parallel.
+
+    # Raised exceptions
+
+    A _ValueError_ exception is raised if the workflow is not a valid.
+    """
+    valid, extra = validate_schema(WORKFLOW, workflow)
+    if not valid:
+        raise ValueError(extra)
+
+    if declaration := workflow.get('inputs'):
+        try:
+            _validate_defaults(declaration)
+        except ValueError as err:
+            raise ValueError(
+                f'Invalid "inputs" section, default value for {err}'
+            ) from None
+
+    valid, extra = validate_pipeline(workflow)
+    if not valid:
+        raise ValueError(extra)
+
+    return extra
+
+
+# Inputs Helpers
+
+INPUTSTYPE_VALIDATION = {'string': (str,), 'boolean': (bool,), 'number': (int, float)}
+
+
+def _normalize_inputs(inputs: Dict[str, Any]) -> None:
+    """Normalize inputs.
+
+    The 'normalized' form for inputs is with `-` separators, not `_`.
+
+    Non-normalized inputs are removed from the dictionary.
+
+    # Raised exceptions
+
+    A _ValueError_ exception is raised if an input is provided twice, in
+    a normalized as well as a non-normalized form.
+    """
+    for key in inputs.copy():
+        if '_' not in key:
+            continue
+        normalized = key.replace('_', '-')
+        if normalized in inputs:
+            raise ValueError(f'Both "{key}" and "{normalized}" specified in inputs.')
+        inputs[normalized] = inputs.pop(key)
+
+
+def _set_default(inputs: Dict[str, Any], key: str, spec: Dict[str, Any]) -> None:
+    if (default := spec.get('default')) is not None:
+        inputs[key] = default
+    elif type_ := spec.get('type'):
+        if type_ == 'string':
+            inputs[key] = ''
+        elif type_ == 'number':
+            inputs[key] = 0
+        elif type_ == 'boolean':
+            inputs[key] = False
+
+
+def validate_value(spec: Dict[str, Any], val: Any) -> Any:
+    """Validate a value.
+
+    # Required parameters
+
+    - spec: a dictionary
+    - val: the value to validate
+
+    # Returned value
+
+    The validated value, converted to the expected type if appropriate.
+
+    # Raised exceptions
+
+    A _ValueError_ exception is raised if the validation fails.
+    """
+    type_ = spec.get('type')
+
+    if type_ == 'choice':
+        if val in spec['options']:
+            return val
+        allowed = '", "'.join(sorted(spec['options']))
+        raise ValueError(f'Invalid value "{val}".  Allowed values: "{allowed}".')
+
+    if isinstance(val, INPUTSTYPE_VALIDATION.get(type_, object)):
+        return val
+
+    if type_ == 'boolean':
+        if isinstance(val, str) and val.lower() in ('true', 'false'):
+            return val.lower() == 'true'
+        raise ValueError(f'Invalid value "{val}".  Allowed values: "true", "false".')
+    if type_ == 'number':
+        for cast in (int, float):
+            try:
+                return cast(val)
+            except (ValueError, TypeError):
+                pass
+        raise ValueError(f'Invalid value "{val}".  Expected a number.')
+    if type_ == 'string':
+        return str(val)
+
+    raise ValueError(f'Invalid value "{val}".  Expected a {type_}.')
+
+
+def validate_inputs(
+    declaration: Dict[str, Dict[str, Any]],
+    inputs: Dict[str, Any],
+    additional_inputs: bool = False,
+    normalize: bool = True,
+) -> None:
+    """Validate inputs.
+
+    Default values are filled in `inputs` as appropriate.
+
+    Input names are normalized to use hyphens instead of underscores
+    by default (declaration is expected to be normalized in this case).
+
+    If `normalize` is set, non-normalized inputs are removed from the
+    dictionary.
+
+    If declaration contains a pattern (a key starting with '{'),
+    normalization is ignored.
+
+    Choices values are validated.
+
+    Types are enforced if declared as `boolean`, `number`, or `string`.
+    Conversion is performed if needed.
+
+    # Required parameters
+
+    - declaration: a dictionary
+    - inputs: a dictionary
+
+    # Optional parameters
+
+    - additional_inputs: a boolean (False by default)
+    - normalize: a boolean (True by default)
+
+    # Raised exceptions
+
+    A _ValueError_ exception is raised if inputs do not match
+    declaration.
+    """
+    if normalize and not any(key.startswith('{') for key in declaration):
+        _normalize_inputs(inputs)
+
+    for key, spec in declaration.items():
+        if key.startswith('{'):
+            continue
+        if key not in inputs:
+            if spec.get('required'):
+                raise ValueError(f'Mandatory input "{key}" not provided.')
+            _set_default(inputs, key, spec)
+            continue
+        try:
+            inputs[key] = validate_value(spec, inputs[key])
+        except ValueError as err:
+            raise ValueError(f'Input "{key}": {err}') from None
+
+    if additional_inputs:
+        return
+
+    if unexpected := set(inputs) - set(declaration):
+        allowed = '", "'.join(sorted(declaration))
+        unexpected = '", "'.join(sorted(unexpected))
+        raise ValueError(
+            f'Unexpected inputs "{unexpected}" found.  Allowed inputs: "{allowed}".'
+        )
+
+
+def _validate_defaults(declaration: Dict[str, Any]) -> None:
+    """Validate defaults.
+
+    Ensure `default`, if specified, is of the correct type and range.
+    """
+    for key, spec in declaration.items():
+        type_ = spec.get('type')
+        if not (type_ and 'default' in spec):
+            continue
+        default = spec['default']
+        if expected := INPUTSTYPE_VALIDATION.get(type_):
+            if not isinstance(default, expected):
+                raise ValueError(f'"{key}" must be a {type_}, got {repr(default)}.')
+            continue
+        if type_ == 'choice' and default not in spec.get('options'):
+            allowed = '", "'.join(sorted(spec.get('options')))
+            raise ValueError(
+                f'"{key}" must be one of "{allowed}", got {repr(default)}.'
+            )
+
+
+def validate_descriptors(descriptors: Iterable[Dict[str, Any]]) -> None:
+    """Validate descriptors.
+
+    Validate descriptors against PLUGIN_DESCRIPTOR schema for plugins.
+
+    If applicable, `default` values are checked against the input's
+    `type`.
+
+    # Required parameters
+
+    - descriptors: a series of manifests
+
+    # Raised exceptions
+
+    A _ValueError_ exception is raised if a descriptor is invalid.
+    """
+    for manifest in descriptors:
+        try:
+            metadata = manifest['metadata']
+            what = f'{metadata["name"].lower()} {metadata.get("action", "")}'.strip()
+        except Exception as err:
+            raise ValueError(f'Missing "metadata.name" section: {err}.') from None
+        valid, extra = validate_schema(PLUGIN_DESCRIPTOR, manifest)
+        if not valid:
+            raise ValueError(f'"{what}": {extra}')
+        if declaration := manifest.get('inputs'):
+            try:
+                _validate_defaults(declaration)
+            except ValueError as err:
+                raise ValueError(
+                    f'"inputs" section for "{what}", default value for {err}'
+                ) from None

opentf/schemas/config.opentestfactory.org/v1/Descriptor.json

@@ -0,0 +1,323 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema#",
+    "title": "JSON SCHEMA for opentestfactory inputs",
+    "description": "An events/inputs/outputs part in a plugin descriptor.",
+    "type": "object",
+    "properties": {
+        "apiVersion": {
+            "type": "string"
+        },
+        "kind": {
+            "type": "string"
+        },
+        "metadata": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "title": {
+                    "type": "string"
+                },
+                "action": {
+                    "type": "string"
+                },
+                "description": {
+                    "type": "string"
+                },
+                "note": {
+                    "type": "string"
+                },
+                "license": {
+                    "type": "string"
+                },
+                "hooks": {
+                    "const": "default"
+                },
+                "variables": {
+                    "const": "default"
+                }
+            },
+            "required": [
+                "name"
+            ],
+            "additionalProperties": true
+        },
+        "cmd": {
+            "type": "string"
+        },
+        "spec": {
+            "type": "object",
+            "properties": {
+                "contextParameters": {
+                    "$ref": "#/definitions/contextparameters"
+                },
+                "variables": {
+                    "$ref": "#/definitions/variables"
+                }
+            },
+            "patternProperties": {
+                "^.*\\..*$": {
+                    "type": [
+                        "string",
+                        "array",
+                        "object"
+                    ]
+                }
+            },
+            "required": [],
+            "additionalProperties": false
+        },
+        "events": {
+            "type": "array",
+            "minItems": 1
+        },
+        "inputs": {
+            "$ref": "#/definitions/inputs"
+        },
+        "additionalInputs": {
+            "type": "boolean"
+        },
+        "outputs": {
+            "$ref": "#/definitions/outputs"
+        },
+        "reports": {
+            "type": "object"
+        },
+        "branding": {
+            "type": "object"
+        }
+    },
+    "required": [
+        "metadata"
+    ],
+    "allOf": [
+        {
+            "if": {
+                "properties": {
+                    "metadata": {
+                        "properties": {
+                            "action": {
+                                "type": "string"
+                            }
+                        },
+                        "required": [
+                            "action"
+                        ]
+                    }
+                }
+            },
+            "then": {
+                "required": [
+                    "events"
+                ]
+            }
+        },
+        {
+            "if": {
+                "properties": {
+                    "additionalInputs": {
+                    }
+                },
+                "required": [
+                    "additionalInputs"
+                ]
+            },
+            "then": {
+                "required": [
+                    "inputs"
+                ]
+            }
+        }
+    ],
+    "additionalProperties": false,
+    "definitions": {
+        "contextparameters": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string"
+                    },
+                    "descriptiveName": {
+                        "type": "string"
+                    },
+                    "description": {
+                        "type": "string"
+                    },
+                    "deprecatedNames": {
+                        "type": "array",
+                        "minItems": 1,
+                        "items": {
+                            "type": "string"
+                        }
+                    },
+                    "type": {
+                        "enum": [
+                            "string",
+                            "number",
+                            "boolean",
+                            "choice",
+                            "int",
+                            "bool"
+                        ]
+                    },
+                    "options": {
+                        "type": "array",
+                        "minItems": 1,
+                        "items": {
+                            "type": "string"
+                        }
+                    },
+                    "default": {},
+                    "minValue": { "type": "number" },
+                    "maxValue": { "type": "number" },
+                    "shared": {
+                        "type": "boolean"
+                    }
+                },
+                "required": [
+                    "name",
+                    "descriptiveName"
+                ],
+                "allOf": [
+                    {
+                        "$ref": "#/definitions/choice"
+                    }
+                ],
+                "additionalProperties": false
+            }
+        },
+        "variables": {
+            "type": "object",
+            "minProperties": 1,
+            "patternProperties": {
+                "^[a-zA-Z0-9_]+$": {
+                    "type": "object",
+                    "properties": {
+                        "descriptiveName": {
+                            "type": "string"
+                        },
+                        "description": {
+                            "type": "string"
+                        },
+                        "default": {
+                            "type": "string"
+                        },
+                        "required": {
+                            "type": "boolean"
+                        },
+                        "masked": {
+                            "type": "boolean"
+                        }
+                    },
+                    "required": [
+                        "descriptiveName"
+                    ],
+                    "additionalProperties": false
+                }
+            }
+        },
+        "inputs": {
+            "type": "object",
+            "minProperties": 0,
+            "patternProperties": {
+                "^[a-zA-Z-][a-zA-Z0-9-]*$|^{.*": {
+                    "type": "object",
+                    "properties": {
+                        "description": {
+                            "type": "string"
+                        },
+                        "required": {
+                            "type": "boolean"
+                        },
+                        "default": {},
+                        "type": {
+                            "enum": [
+                                "string",
+                                "number",
+                                "boolean",
+                                "choice"
+                            ]
+                        },
+                        "options": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": {
+                                "type": "string"
+                            }
+                        },
+                        "depreciationMessage": {
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "description"
+                    ],
+                    "allOf": [
+                        {
+                            "$ref": "#/definitions/choice"
+                        }
+                    ],
+                    "additionalProperties": false
+                }
+            },
+            "additionalProperties": false
+        },
+        "outputs": {
+            "type": "object",
+            "minProperties": 1,
+            "patternProperties": {
+                "^[a-zA-Z_][a-zA-Z0-9_-]*$": {
+                    "oneOf": [
+                        {
+                            "type": "object",
+                            "properties": {
+                                "description": {
+                                    "type": "string"
+                                },
+                                "value": {
+                                    "type": "string"
+                                }
+                            },
+                            "required": [
+                                "value"
+                            ],
+                            "additionalProperties": false
+                        },
+                        {
+                            "type": "string"
+                        }
+                    ]
+                }
+            },
+            "additionalProperties": false
+        },
+        "choice": {
+            "if": {
+                "properties": {
+                    "type": {
+                        "const": "choice"
+                    }
+                },
+                "required": [
+                    "type"
+                ]
+            },
+            "then": {
+                "required": [
+                    "options"
+                ]
+            },
+            "else": {
+                "not": {
+                    "required": [
+                        "options"
+                    ]
+                }
+            }
+        }
+    }
+}

opentf/schemas/opentestfactory.org/v1/Workflow.json

@@ -552,7 +552,6 @@
                             "type": "boolean"
                         },
                         "default": {
-                            "type": "string"
                         },
                         "type": {
                             "enum": [

opentf/toolkit/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (c) Henix, Henix.fr
+# Copyright (c) 2021 Henix, Henix.fr
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@
 
 """A toolkit for creating OpenTestFactory plugins."""
 
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 import os
 import threading
@@ -34,13 +34,16 @@ from opentf.commons import (
     subscribe,
     unsubscribe,
     EXECUTIONCOMMAND,
+    EXECUTIONRESULT,
     PROVIDERCOMMAND,
     PROVIDERCONFIG,
     GENERATORCOMMAND,
     SERVICECONFIG,
     CHANNEL_HOOKS,
+    PLUGIN_DESCRIPTOR,
     make_dispatchqueue,
     make_status_response,
+    validate_descriptors,
     validate_inputs,
     validate_schema,
 )
@@ -465,23 +468,10 @@ def _subscribe(
         manifest.get('inputs', {}),
         manifest.get('additionalInputs'),
     )
-    try:
-        context[OUTPUTS_KEY][(cat_prefix, cat, cat_version)] = {
-            k: v['value'] if isinstance(v, dict) else v
-            for k, v in manifest.get('outputs', {}).items()
-        }
-    except KeyError as err:
-        plugin.logger.error(
-            'Invalid descriptor "outputs" section, could not find key %s in: %s.',
-            err,
-            manifest.get('outputs', {}),
-        )
-        sys.exit(2)
-    except Exception as err:
-        plugin.logger.error(
-            'Invalid descriptor "outputs" section, got %s while parsing outputs.', err
-        )
-        sys.exit(2)
+    context[OUTPUTS_KEY][(cat_prefix, cat, cat_version)] = {
+        k: v['value'] if isinstance(v, dict) else v
+        for k, v in manifest.get('outputs', {}).items()
+    }
     return subscribe(kind=kind, target='inbox', app=plugin, labels=labels)
 
 
@@ -574,14 +564,14 @@ def make_plugin(
     - configfile: a string or None (None by default)
     - args: a list or None (None by default)
 
+    # Returned value
+
+    A plugin service (not started).
+
     # Raised exceptions
 
     A _ValueError_ exception is raised if the provided parameters are
     invalid.
-
-    # Returned value
-
-    A plugin service (not started).
     """
 
     def process_inbox():
@@ -600,7 +590,7 @@ def make_plugin(
             except KeyError:
                 return make_status_response(
                     'BadRequest',
-                    f'Not a valid {kind} request: Missing metadata section',
+                    f'Not a valid {kind} request: Missing "metadata" section',
                 )
 
         valid, extra = validate_schema(kind, body)
@@ -643,11 +633,6 @@ def make_plugin(
             '"args" is required for channel plugins and must be a list of one element.'
         )
 
-    kind = (
-        EXECUTIONCOMMAND
-        if channel
-        else GENERATORCOMMAND if generator else PROVIDERCOMMAND
-    )
     if not schema:
         schema = SERVICECONFIG if generator else PROVIDERCONFIG
 
@@ -658,8 +643,18 @@ def make_plugin(
         schema=schema,
         descriptor=descriptor if descriptor is not None else 'plugin.yaml',
     )
-    plugin.route('/inbox', methods=['POST'])(process_inbox)
+
+    if channel:
+        kind = EXECUTIONCOMMAND
+    elif generator:
+        kind = GENERATORCOMMAND
+    elif publisher:
+        kind = EXECUTIONRESULT
+    else:
+        kind = PROVIDERCOMMAND
+
     plugin.config['CONTEXT'][KIND_KEY] = kind
+    plugin.route('/inbox', methods=['POST'])(process_inbox)
 
     if kind == PROVIDERCOMMAND:
         _maybe_add_hook_watcher(plugin, schema)

{opentf_toolkit_nightly-0.62.0.dev1347.dist-info → opentf_toolkit_nightly-0.62.0.dev1370.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opentf-toolkit-nightly
-Version: 0.62.0.dev1347
+Version: 0.62.0.dev1370
 Summary: OpenTestFactory Orchestrator Toolkit
 Home-page: https://gitlab.com/henixdevelopment/open-source/opentestfactory/python-toolkit
 Author: Martin Lafaix

{opentf_toolkit_nightly-0.62.0.dev1347.dist-info → opentf_toolkit_nightly-0.62.0.dev1370.dist-info}/RECORD

@@ -1,21 +1,22 @@
-opentf/commons/__init__.py,sha256=BVz2VMgMa0oCwCBXSLxL8ZTDeAn-CBzcK4rYiHEtVSw,28393
+opentf/commons/__init__.py,sha256=N8GrBU1oL4sDUB4iVF5kPVB__uBlhe4FwD8E5ITV2pI,23011
 opentf/commons/auth.py,sha256=yUmAoZPk9Aru2UVT5xSjH96u9DOKPk17AeL1_12mjBM,16399
-opentf/commons/config.py,sha256=gcge4zou7wMgu3GTyM5vVZudTyEpuyi3JEY8cdCBf5A,10454
+opentf/commons/config.py,sha256=WiXoxuWQUebHrWAIY1fkxpwKb17uCnG29_8cZ2CaCcE,10454
 opentf/commons/exceptions.py,sha256=7dhUXO8iyAbqVwlUKxZhgRzGqVcb7LkG39hFlm-VxIA,2407
 opentf/commons/expressions.py,sha256=jM_YKXVOFhvOE2aE2IuacuvxhIsOYTFs2oQkpcbWR6g,19645
 opentf/commons/meta.py,sha256=ygSO3mE2d-Ux62abzK1wYk86noT4R5Tumd90nyZo0MU,3322
 opentf/commons/pubsub.py,sha256=M0bvajR9raUP-xe5mfRjdrweZyHQw1_Qsy56gS-Sck4,7676
-opentf/commons/schemas.py,sha256=MbUt4XLiFKdyL6g-gKwgnKVUs7f5CXrY89vuqT0ehRM,5128
+opentf/commons/schemas.py,sha256=LT8SlkUcJGtqbnUUDT0U1KsQqTEXjl-ShMny332DkMQ,14042
 opentf/commons/selectors.py,sha256=2mmnvfZ13KizBQLsIvHXPU0Qtf6hkIvJpYdejNRszUs,7203
 opentf/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 opentf/schemas/abac.opentestfactory.org/v1alpha1/Policy.json,sha256=JXsfNAPSEYggeyaDutSQBeG38o4Bmcr70dPLWWeqIh8,2105
+opentf/schemas/config.opentestfactory.org/v1/Descriptor.json,sha256=V0ttnb2V9Yz5vWcVbtrSm0yylYp9eTyzEicuxRxjZu0,9541
 opentf/schemas/opentestfactory.org/v1/ExecutionCommand.json,sha256=UtmAlTaYdPSZDeQnx-ocX8IonyEPWoNmgDkHwQwQxWE,4126
 opentf/schemas/opentestfactory.org/v1/ExecutionResult.json,sha256=u0n-WYXNX9d0cEyu2D4tegU35k2Gf3eA6PGs9Uz4QDg,3275
 opentf/schemas/opentestfactory.org/v1/GeneratorResult.json,sha256=sOwieyDWi6UZR7X29R9IjOR87ruSRQ4U6CM2_yT81Zk,16607
 opentf/schemas/opentestfactory.org/v1/ProviderCommand.json,sha256=EU4kvEKxlqpH2IkLZ1HdBealuG6C0YzPkAtI7dNrfHg,4427
 opentf/schemas/opentestfactory.org/v1/ProviderResult.json,sha256=Ej4zhCE3rCqCGKcaeAoIHwSJTV_7fw-rAxhJ52qA-Gs,9641
 opentf/schemas/opentestfactory.org/v1/Subscription.json,sha256=hNaCUW3qSqqa1LY01Ao7kQ8FJhkjkwMrrPf4xihgSt4,7150
-opentf/schemas/opentestfactory.org/v1/Workflow.json,sha256=17EE3VgrjSe_nOufJ2UZbgWbOSnK8Yu4TxIoJjGEkF4,24229
+opentf/schemas/opentestfactory.org/v1/Workflow.json,sha256=5SoyzTHvCxx7ygSK0A8y66VJwNfk2tQkoFuxbvook6Y,24184
 opentf/schemas/opentestfactory.org/v1/WorkflowCanceled.json,sha256=BCWxnm3rt4VWh9GXkIhdNY9JYohFWxi9Wg3JjXIavaU,1694
 opentf/schemas/opentestfactory.org/v1/WorkflowCancellation.json,sha256=HAtc8xjrr-WwXwIck9B86BrHELkCb1oPYhTsRzHMMOE,1993
 opentf/schemas/opentestfactory.org/v1/WorkflowCompleted.json,sha256=KtC9-oeaBNM3D60SFpmYnLMtqewUAGRoOJfVzb7CdHg,1635
@@ -56,11 +57,11 @@ opentf/schemas/opentestfactory.org/v1beta1/Workflow.json,sha256=QZ8mM9PhzsI9gTmw
 opentf/schemas/opentestfactory.org/v1beta2/ServiceConfig.json,sha256=rEvK2YWL5lG94_qYgR_GnLWNsaQhaQ-2kuZdWJr5NnY,3517
 opentf/scripts/launch_java_service.sh,sha256=S0jAaCuv2sZy0Gf2NGBuPX-eD531rcM-b0fNyhmzSjw,2423
 opentf/scripts/startup.py,sha256=AcVXU2auPvqMb_6OpGzkVqrpgYV6vz7x_Rnv8YbAEkk,23114
-opentf/toolkit/__init__.py,sha256=7MGAfKb5V9ckzWE8ozfj0PcC7g0a-0VfdyrClkWTk38,22319
+opentf/toolkit/__init__.py,sha256=EBTZJ3srbzrLDd4fCmEN5C4NnoZ2kKhpE1aj6oMPtPs,22041
 opentf/toolkit/channels.py,sha256=6qKSsAgq_oJpuDRiKqVUz-EAjdfikcCG3SFAGmKZdhQ,25551
 opentf/toolkit/core.py,sha256=8REPRzLWrN50B2VMz8yO-AClgOOt8MsqYdafDw2my48,9608
-opentf_toolkit_nightly-0.62.0.dev1347.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-opentf_toolkit_nightly-0.62.0.dev1347.dist-info/METADATA,sha256=9iyT0PpbkoJPaIPZiVj867iz0wm6QV2YRAbUQstQyIA,2214
-opentf_toolkit_nightly-0.62.0.dev1347.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-opentf_toolkit_nightly-0.62.0.dev1347.dist-info/top_level.txt,sha256=_gPuE6GTT6UNXy1DjtmQSfCcZb_qYA2vWmjg7a30AGk,7
-opentf_toolkit_nightly-0.62.0.dev1347.dist-info/RECORD,,
+opentf_toolkit_nightly-0.62.0.dev1370.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+opentf_toolkit_nightly-0.62.0.dev1370.dist-info/METADATA,sha256=PBI7Oca_P0qepFNUHfghv_WhMcudi860YzIxk93M9JQ,2214
+opentf_toolkit_nightly-0.62.0.dev1370.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+opentf_toolkit_nightly-0.62.0.dev1370.dist-info/top_level.txt,sha256=_gPuE6GTT6UNXy1DjtmQSfCcZb_qYA2vWmjg7a30AGk,7
+opentf_toolkit_nightly-0.62.0.dev1370.dist-info/RECORD,,