PackAPI.validate() - Code Metrics - Inspection of "Merge pull request #3101 from StackStorm/more_frie..." - StackStorm/st2 - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — develop ( f42457...ddb9d3 )

by Plexxi

created 2016-12-12 11:00 UTC

PackAPI.validate() B

↳ Parent: PackAPI

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	4
c	2
b	0
f	0
dl	0
loc	24
rs	8.6845

# Licensed to the StackStorm, Inc ('StackStorm') under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import os

import jsonschema
from oslo_config import cfg

from st2common import log as logging
from st2common.util import schema as util_schema
from st2common.constants.keyvalue import SYSTEM_SCOPE
from st2common.constants.keyvalue import USER_SCOPE
from st2common.constants.pack import PACK_REF_WHITELIST_REGEX
from st2common.constants.pack import PACK_VERSION_REGEX
from st2common.constants.pack import ST2_VERSION_REGEX
from st2common.constants.pack import NORMALIZE_PACK_VERSION
from st2common.persistence.pack import ConfigSchema
from st2common.models.api.base import BaseAPI
from st2common.models.db.pack import PackDB
from st2common.models.db.pack import ConfigSchemaDB
from st2common.models.db.pack import ConfigDB
from st2common.exceptions.db import StackStormDBObjectNotFoundError
from st2common.util.pack import validate_config_against_schema
from st2common.util.pack import normalize_pack_version

__all__ = [
    'PackAPI',
    'ConfigSchemaAPI',
    'ConfigAPI',

    'ConfigItemSetAPI',

    'PackInstallRequestAPI',
    'PackRegisterRequestAPI',
    'PackSearchRequestAPI',
    'PackAsyncAPI'
]

LOG = logging.getLogger(__name__)


class PackAPI(BaseAPI):
    model = PackDB
    schema = {
        'type': 'object',
        'description': 'Content pack schema.',
        'properties': {
            'id': {
                'type': 'string',
                'description': 'Unique identifier for the pack.',
                'default': None
            },
            'name': {
                'type': 'string',
                'description': 'Display name of the pack. If the name only contains lowercase'
                               'letters, digits and underscores, the "ref" field is not required.',
                'required': True
            },
            'ref': {
                'type': 'string',
                'description': 'Reference for the pack, used as an internal id.',
                'default': None,
                'pattern': PACK_REF_WHITELIST_REGEX
            },
            'uid': {
                'type': 'string'
            },
            'description': {
                'type': 'string',
                'description': 'Brief description of the pack and the service it integrates with.',
                'required': True
            },
            'keywords': {
                'type': 'array',
                'description': 'Keywords describing the pack.',
                'items': {'type': 'string'},
                'default': []
            },
            'version': {
                'type': 'string',
                'description': 'Pack version. Must follow the semver format '
                               '(for instance, "0.1.0").',
                'pattern': PACK_VERSION_REGEX,
                'required': True
            },
            'stackstorm_version': {
                'type': 'string',
                'description': 'Required StackStorm version. Examples: ">1.6.0", '
                               '">=1.8.0, <2.2.0"',
                'pattern': ST2_VERSION_REGEX,
            },
            'author': {
                'type': 'string',
                'description': 'Pack author or authors.',
                'required': True
            },
            'email': {
                'type': 'string',
                'description': 'E-mail of the pack author.',
                'format': 'email'
            },
            'contributors': {
                'type': 'array',
                'items': {
                    'type': 'string',
                    'maxLength': 100
                },
                'description': ('A list of people who have contributed to the pack. Format is: '
                                'Name <email address> e.g. Tomaz Muraus <[email protected]>.')
            },
            'files': {
                'type': 'array',
                'description': 'A list of files inside the pack.',
                'items': {'type': 'string'},
                'default': []
            },
            'dependencies': {
                'type': 'array',
                'description': 'A list of other StackStorm packs this pack depends upon. '
                               'The same format as in "st2 pack install" is used: '
                               '"<name or full URL>[=<version or git ref>]".',
                'items': {'type': 'string'},
                'default': []
            },
            'system': {
                'type': 'object',
                'description': 'Specification for the system components and packages '
                               'required for the pack.',
                'default': {}
            }
        }
    }

    def __init__(self, **values):
        name = values.get('name', None)

        # Note: If some version values are not explicitly surrounded by quotes they are recognized
        # as numbers so we cast them to string
        if values.get('version', None):
            values['version'] = str(values['version'])

        # Special case for old version which didn't follow semver format (e.g. 0.1, 1.0, etc.)
        # In case the version doesn't match that format, we simply append ".0" to the end (e.g.
        # 0.1 -> 0.1.0, 1.0, -> 1.0.0, etc.)
        if NORMALIZE_PACK_VERSION:
            new_version = normalize_pack_version(version=values['version'])
            if new_version != values['version']:
                LOG.warning('Pack "%s" contains invalid semver version specifer, casting it to a '

                            'full semver version specifier (%s -> %s).\n'
                            'Short versions will become INVALID in StackStorm 2.2, and the pack '
                            'will stop working. Update the pack version in "pack.yaml".'
                            % (name, values['version'], new_version))
            values['version'] = new_version

        super(PackAPI, self).__init__(**values)

    def validate(self):
        # We wrap default validate() implementation and throw a more user-friendly exception in
        # case pack version doesn't follow a valid semver format and other errors
        try:
            super(PackAPI, self).validate()
        except jsonschema.ValidationError as e:
            msg = str(e)

            # Invalid version
            if "Failed validating 'pattern' in schema['properties']['version']" in msg:
                new_msg = ('Pack version "%s" doesn\'t follow a valid semver format. Valid '
                           'versions and formats include: 0.1.0, 0.2.1, 1.1.0, etc.' %
                           (self.version))
                new_msg += '\n\n' + msg
                raise jsonschema.ValidationError(new_msg)

            # Invalid ref / name
            if "Failed validating 'pattern' in schema['properties']['ref']" in msg:
                new_msg = ('Pack ref / name can only contain valid word characters (a-z, 0-9 and '
                           '_), dashes are not allowed.')
                new_msg += '\n\n' + msg
                raise jsonschema.ValidationError(new_msg)

            raise e

    @classmethod
    def to_model(cls, pack):
        ref = pack.ref
        name = pack.name
        description = pack.description
        keywords = getattr(pack, 'keywords', [])
        version = str(pack.version)

        stackstorm_version = getattr(pack, 'stackstorm_version', None)
        author = pack.author
        email = pack.email
        contributors = getattr(pack, 'contributors', [])
        files = getattr(pack, 'files', [])
        dependencies = getattr(pack, 'dependencies', [])
        system = getattr(pack, 'system', {})

        model = cls.model(ref=ref, name=name, description=description, keywords=keywords,
                          version=version, author=author, email=email, contributors=contributors,
                          files=files, dependencies=dependencies, system=system,
                          stackstorm_version=stackstorm_version)
        return model


class ConfigSchemaAPI(BaseAPI):
    model = ConfigSchemaDB
    schema = {
        "title": "ConfigSchema",
        "description": "Pack config schema.",
        "type": "object",
        "properties": {
            "id": {
                "description": "The unique identifier for the config schema.",
                "type": "string"
            },
            "pack": {
                "description": "The content pack this config schema belongs to.",
                "type": "string"
            },
            "attributes": {
                "description": "Config schema attributes.",
                "type": "object",
                "patternProperties": {
                    "^\w+$": util_schema.get_action_parameters_schema()

                },
                'additionalProperties': False,
                "default": {}
            }
        },
        "additionalProperties": False
    }

    @classmethod
    def to_model(cls, config_schema):
        pack = config_schema.pack
        attributes = config_schema.attributes

        model = cls.model(pack=pack, attributes=attributes)
        return model


class ConfigAPI(BaseAPI):
    model = ConfigDB
    schema = {
        "title": "Config",
        "description": "Pack config.",
        "type": "object",
        "properties": {
            "id": {
                "description": "The unique identifier for the config.",
                "type": "string"
            },
            "pack": {
                "description": "The content pack this config belongs to.",
                "type": "string"
            },
            "values": {
                "description": "Config values.",
                "type": "object",
                "default": {}
            }
        },
        "additionalProperties": False
    }

    def validate(self, validate_against_schema=False):

        # Perform base API model validation against json schema
        result = super(ConfigAPI, self).validate()

        # Perform config values validation against the config values schema
        if validate_against_schema:
            cleaned_values = self._validate_config_values_against_schema()
            result.values = cleaned_values

        return result

    def _validate_config_values_against_schema(self):
        try:
            config_schema_db = ConfigSchema.get_by_pack(value=self.pack)
        except StackStormDBObjectNotFoundError:
            # Config schema is optional
            return

        # Note: We are doing optional validation so for now, we do allow additional properties
        instance = self.values or {}
        schema = config_schema_db.attributes

        configs_path = os.path.join(cfg.CONF.system.base_path, 'configs/')
        config_path = os.path.join(configs_path, '%s.yaml' % (self.pack))

        cleaned = validate_config_against_schema(config_schema=schema,
                                                 config_object=instance,
                                                 config_path=config_path,
                                                 pack_name=self.pack)

        return cleaned

    @classmethod
    def to_model(cls, config):
        pack = config.pack
        values = config.values

        model = cls.model(pack=pack, values=values)
        return model


class ConfigUpdateRequestAPI(BaseAPI):
    schema = {
        "type": "object"
    }


class ConfigItemSetAPI(BaseAPI):
    """
    API class used with the config set API endpoint.
    """
    model = None
    schema = {
        "title": "",
        "description": "",
        "type": "object",
        "properties": {
            "name": {
                "description": "Config item name (key)",
                "type": "string",
                "required": True
            },
            "value": {
                "description": "Config item value.",
                "type": ["string", "number", "boolean", "array", "object"],
                "required": True
            },
            "scope": {
                "description": "Config item scope (system / user)",
                "type": "string",
                "default": SYSTEM_SCOPE,
                "enum": [
                    SYSTEM_SCOPE,
                    USER_SCOPE
                ]
            },
            "user": {
                "description": "User for user-scoped items (only available to admins).",
                "type": "string",
                "required": False,
                "default": None
            }
        },
        "additionalProperties": False
    }


class PackInstallRequestAPI(BaseAPI):
    schema = {
        "type": "object",
        "properties": {
            "packs": {
                "type": "array"
            },
            "force": {
                "type": "boolean",
                "description": "Force pack installation",
                "default": False
            }
        }
    }


class PackRegisterRequestAPI(BaseAPI):
    schema = {
        "type": "object",
        "properties": {
            "types": {
                "type": "array",
                "items": {
                    "type": "string"
                }
            },
            "packs": {
                "type": "array",
                "items": {
                    "type": "string"
                }
            }
        }
    }


class PackSearchRequestAPI(BaseAPI):
    schema = {
        "type": "object",
        "oneOf": [
            {
                "properties": {
                    "query": {
                        "type": "string",
                        "required": True,
                    },
                },
                "additionalProperties": False,
            },
            {
                "properties": {
                    "pack": {
                        "type": "string",
                        "required": True,
                    },
                },
                "additionalProperties": False,
            },
        ]
    }


class PackAsyncAPI(BaseAPI):
    schema = {
        "type": "object",
        "properties": {
            "execution_id": {
                "type": "string",
                "required": True
            }
        },
        "additionalProperties": False
    }


1			# Licensed to the StackStorm, Inc ('StackStorm') under one or more
2			# contributor license agreements. See the NOTICE file distributed with
3			# this work for additional information regarding copyright ownership.
4			# The ASF licenses this file to You under the Apache License, Version 2.0
5			# (the "License"); you may not use this file except in compliance with
6			# the License. You may obtain a copy of the License at
7			#
8			# http://www.apache.org/licenses/LICENSE-2.0
9			#
10			# Unless required by applicable law or agreed to in writing, software
11			# distributed under the License is distributed on an "AS IS" BASIS,
12			# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13			# See the License for the specific language governing permissions and
14			# limitations under the License.
15
16			import os
17
18			import jsonschema
19			from oslo_config import cfg
20
21			from st2common import log as logging
22			from st2common.util import schema as util_schema
23			from st2common.constants.keyvalue import SYSTEM_SCOPE
24			from st2common.constants.keyvalue import USER_SCOPE
25			from st2common.constants.pack import PACK_REF_WHITELIST_REGEX
26			from st2common.constants.pack import PACK_VERSION_REGEX
27			from st2common.constants.pack import ST2_VERSION_REGEX
28			from st2common.constants.pack import NORMALIZE_PACK_VERSION
29			from st2common.persistence.pack import ConfigSchema
30			from st2common.models.api.base import BaseAPI
31			from st2common.models.db.pack import PackDB
32			from st2common.models.db.pack import ConfigSchemaDB
33			from st2common.models.db.pack import ConfigDB
34			from st2common.exceptions.db import StackStormDBObjectNotFoundError
35			from st2common.util.pack import validate_config_against_schema
36			from st2common.util.pack import normalize_pack_version
37
38			__all__ = [
39			'PackAPI',
40			'ConfigSchemaAPI',
41			'ConfigAPI',
42
43			'ConfigItemSetAPI',
44
45			'PackInstallRequestAPI',
46			'PackRegisterRequestAPI',
47			'PackSearchRequestAPI',
48			'PackAsyncAPI'
49			]
50
51			LOG = logging.getLogger(__name__)
52
53
54			class PackAPI(BaseAPI):
55			model = PackDB
56			schema = {
57			'type': 'object',
58			'description': 'Content pack schema.',
59			'properties': {
60			'id': {
61			'type': 'string',
62			'description': 'Unique identifier for the pack.',
63			'default': None
64			},
65			'name': {
66			'type': 'string',
67			'description': 'Display name of the pack. If the name only contains lowercase'
68			'letters, digits and underscores, the "ref" field is not required.',
69			'required': True
70			},
71			'ref': {
72			'type': 'string',
73			'description': 'Reference for the pack, used as an internal id.',
74			'default': None,
75			'pattern': PACK_REF_WHITELIST_REGEX
76			},
77			'uid': {
78			'type': 'string'
79			},
80			'description': {
81			'type': 'string',
82			'description': 'Brief description of the pack and the service it integrates with.',
83			'required': True
84			},
85			'keywords': {
86			'type': 'array',
87			'description': 'Keywords describing the pack.',
88			'items': {'type': 'string'},
89			'default': []
90			},
91			'version': {
92			'type': 'string',
93			'description': 'Pack version. Must follow the semver format '
94			'(for instance, "0.1.0").',
95			'pattern': PACK_VERSION_REGEX,
96			'required': True
97			},
98			'stackstorm_version': {
99			'type': 'string',
100			'description': 'Required StackStorm version. Examples: ">1.6.0", '
101			'">=1.8.0, <2.2.0"',
102			'pattern': ST2_VERSION_REGEX,
103			},
104			'author': {
105			'type': 'string',
106			'description': 'Pack author or authors.',
107			'required': True
108			},
109			'email': {
110			'type': 'string',
111			'description': 'E-mail of the pack author.',
112			'format': 'email'
113			},
114			'contributors': {
115			'type': 'array',
116			'items': {
117			'type': 'string',
118			'maxLength': 100
119			},
120			'description': ('A list of people who have contributed to the pack. Format is: '
121			'Name <email address> e.g. Tomaz Muraus <[email protected]>.')
122			},
123			'files': {
124			'type': 'array',
125			'description': 'A list of files inside the pack.',
126			'items': {'type': 'string'},
127			'default': []
128			},
129			'dependencies': {
130			'type': 'array',
131			'description': 'A list of other StackStorm packs this pack depends upon. '
132			'The same format as in "st2 pack install" is used: '
133			'"<name or full URL>[=<version or git ref>]".',
134			'items': {'type': 'string'},
135			'default': []
136			},
137			'system': {
138			'type': 'object',
139			'description': 'Specification for the system components and packages '
140			'required for the pack.',
141			'default': {}
142			}
143			}
144			}
145
146			def __init__(self, **values):
147			name = values.get('name', None)
148
149			# Note: If some version values are not explicitly surrounded by quotes they are recognized
150			# as numbers so we cast them to string
151			if values.get('version', None):
152			values['version'] = str(values['version'])
153
154			# Special case for old version which didn't follow semver format (e.g. 0.1, 1.0, etc.)
155			# In case the version doesn't match that format, we simply append ".0" to the end (e.g.
156			# 0.1 -> 0.1.0, 1.0, -> 1.0.0, etc.)
157			if NORMALIZE_PACK_VERSION:
158			new_version = normalize_pack_version(version=values['version'])
159			if new_version != values['version']:
160			LOG.warning('Pack "%s" contains invalid semver version specifer, casting it to a '
			0 ignored issues – show Coding Style Best Practice introduced 2016-11-02 18:13 UTC by Report Bug Copy Issue Report Specify string format arguments as logging function parameters Loading history...
161			'full semver version specifier (%s -> %s).\n'
162			'Short versions will become INVALID in StackStorm 2.2, and the pack '
163			'will stop working. Update the pack version in "pack.yaml".'
164			% (name, values['version'], new_version))
165			values['version'] = new_version
166
167			super(PackAPI, self).__init__(**values)
168
169			def validate(self):
170			# We wrap default validate() implementation and throw a more user-friendly exception in
171			# case pack version doesn't follow a valid semver format and other errors
172			try:
173			super(PackAPI, self).validate()
174			except jsonschema.ValidationError as e:
175			msg = str(e)
176
177			# Invalid version
178			if "Failed validating 'pattern' in schema['properties']['version']" in msg:
179			new_msg = ('Pack version "%s" doesn\'t follow a valid semver format. Valid '
180			'versions and formats include: 0.1.0, 0.2.1, 1.1.0, etc.' %
181			(self.version))
182			new_msg += '\n\n' + msg
183			raise jsonschema.ValidationError(new_msg)
184
185			# Invalid ref / name
186			if "Failed validating 'pattern' in schema['properties']['ref']" in msg:
187			new_msg = ('Pack ref / name can only contain valid word characters (a-z, 0-9 and '
188			'_), dashes are not allowed.')
189			new_msg += '\n\n' + msg
190			raise jsonschema.ValidationError(new_msg)
191
192			raise e
193
194			@classmethod
195			def to_model(cls, pack):
196			ref = pack.ref
197			name = pack.name
198			description = pack.description
199			keywords = getattr(pack, 'keywords', [])
200			version = str(pack.version)
201
202			stackstorm_version = getattr(pack, 'stackstorm_version', None)
203			author = pack.author
204			email = pack.email
205			contributors = getattr(pack, 'contributors', [])
206			files = getattr(pack, 'files', [])
207			dependencies = getattr(pack, 'dependencies', [])
208			system = getattr(pack, 'system', {})
209
210			model = cls.model(ref=ref, name=name, description=description, keywords=keywords,
211			version=version, author=author, email=email, contributors=contributors,
212			files=files, dependencies=dependencies, system=system,
213			stackstorm_version=stackstorm_version)
214			return model
215
216
217			class ConfigSchemaAPI(BaseAPI):
218			model = ConfigSchemaDB
219			schema = {
220			"title": "ConfigSchema",
221			"description": "Pack config schema.",
222			"type": "object",
223			"properties": {
224			"id": {
225			"description": "The unique identifier for the config schema.",
226			"type": "string"
227			},
228			"pack": {
229			"description": "The content pack this config schema belongs to.",
230			"type": "string"
231			},
232			"attributes": {
233			"description": "Config schema attributes.",
234			"type": "object",
235			"patternProperties": {
236			"^\w+$": util_schema.get_action_parameters_schema()
			0 ignored issues – show Bug introduced 2016-05-13 14:25 UTC by Report Bug Copy Issue Report A suspicious escape sequence `\w` was found. Did you maybe forget to add an `r` prefix? Escape sequences in Python are generally interpreted according to rules similar to standard C. Only if strings are prefixed with `r` or `R` are they interpreted as regular expressions. The escape sequence that was used indicates that you might have intended to write a regular expression. Learn more about the available escape sequences. in the Python documentation. Loading history...
237			},
238			'additionalProperties': False,
239			"default": {}
240			}
241			},
242			"additionalProperties": False
243			}
244
245			@classmethod
246			def to_model(cls, config_schema):
247			pack = config_schema.pack
248			attributes = config_schema.attributes
249
250			model = cls.model(pack=pack, attributes=attributes)
251			return model
252
253
254			class ConfigAPI(BaseAPI):
255			model = ConfigDB
256			schema = {
257			"title": "Config",
258			"description": "Pack config.",
259			"type": "object",
260			"properties": {
261			"id": {
262			"description": "The unique identifier for the config.",
263			"type": "string"
264			},
265			"pack": {
266			"description": "The content pack this config belongs to.",
267			"type": "string"
268			},
269			"values": {
270			"description": "Config values.",
271			"type": "object",
272			"default": {}
273			}
274			},
275			"additionalProperties": False
276			}
277
278			def validate(self, validate_against_schema=False):
			0 ignored issues – show Bug introduced 2016-07-28 14:50 UTC by Report Bug Copy Issue Report Arguments number differs from overridden 'validate' method Loading history...
279			# Perform base API model validation against json schema
280			result = super(ConfigAPI, self).validate()
281
282			# Perform config values validation against the config values schema
283			if validate_against_schema:
284			cleaned_values = self._validate_config_values_against_schema()
285			result.values = cleaned_values
286
287			return result
288
289			def _validate_config_values_against_schema(self):
290			try:
291			config_schema_db = ConfigSchema.get_by_pack(value=self.pack)
292			except StackStormDBObjectNotFoundError:
293			# Config schema is optional
294			return
295
296			# Note: We are doing optional validation so for now, we do allow additional properties
297			instance = self.values or {}
298			schema = config_schema_db.attributes
299
300			configs_path = os.path.join(cfg.CONF.system.base_path, 'configs/')
301			config_path = os.path.join(configs_path, '%s.yaml' % (self.pack))
302
303			cleaned = validate_config_against_schema(config_schema=schema,
304			config_object=instance,
305			config_path=config_path,
306			pack_name=self.pack)
307
308			return cleaned
309
310			@classmethod
311			def to_model(cls, config):
312			pack = config.pack
313			values = config.values
314
315			model = cls.model(pack=pack, values=values)
316			return model
317
318
319			class ConfigUpdateRequestAPI(BaseAPI):
320			schema = {
321			"type": "object"
322			}
323
324
325			class ConfigItemSetAPI(BaseAPI):
326			"""
327			API class used with the config set API endpoint.
328			"""
329			model = None
330			schema = {
331			"title": "",
332			"description": "",
333			"type": "object",
334			"properties": {
335			"name": {
336			"description": "Config item name (key)",
337			"type": "string",
338			"required": True
339			},
340			"value": {
341			"description": "Config item value.",
342			"type": ["string", "number", "boolean", "array", "object"],
343			"required": True
344			},
345			"scope": {
346			"description": "Config item scope (system / user)",
347			"type": "string",
348			"default": SYSTEM_SCOPE,
349			"enum": [
350			SYSTEM_SCOPE,
351			USER_SCOPE
352			]
353			},
354			"user": {
355			"description": "User for user-scoped items (only available to admins).",
356			"type": "string",
357			"required": False,
358			"default": None
359			}
360			},
361			"additionalProperties": False
362			}
363
364
365			class PackInstallRequestAPI(BaseAPI):
366			schema = {
367			"type": "object",
368			"properties": {
369			"packs": {
370			"type": "array"
371			},
372			"force": {
373			"type": "boolean",
374			"description": "Force pack installation",
375			"default": False
376			}
377			}
378			}
379
380
381			class PackRegisterRequestAPI(BaseAPI):
382			schema = {
383			"type": "object",
384			"properties": {
385			"types": {
386			"type": "array",
387			"items": {
388			"type": "string"
389			}
390			},
391			"packs": {
392			"type": "array",
393			"items": {
394			"type": "string"
395			}
396			}
397			}
398			}
399
400
401			class PackSearchRequestAPI(BaseAPI):
402			schema = {
403			"type": "object",
404			"oneOf": [
405			{
406			"properties": {
407			"query": {
408			"type": "string",
409			"required": True,
410			},
411			},
412			"additionalProperties": False,
413			},
414			{
415			"properties": {
416			"pack": {
417			"type": "string",
418			"required": True,
419			},
420			},
421			"additionalProperties": False,
422			},
423			]
424			}
425
426
427			class PackAsyncAPI(BaseAPI):
428			schema = {
429			"type": "object",
430			"properties": {
431			"execution_id": {
432			"type": "string",
433			"required": True
434			}
435			},
436			"additionalProperties": False
437			}
438

StackStorm / st2

Push — develop ( f42457...ddb9d3 )

PackAPI.validate() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like