gerrit.onap Code Review - sdc/sdc-distribution-client.git/blob

   1 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   2 #    not use this file except in compliance with the License. You may obtain
   3 #    a copy of the License at
   4 #
   5 #         http://www.apache.org/licenses/LICENSE-2.0
   6 #
   7 #    Unless required by applicable law or agreed to in writing, software
   8 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   9 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  10 #    License for the specific language governing permissions and limitations
  11 #    under the License.
  12
  13
  14 import logging
  15
  16 from toscaparser.common.exception import ExceptionCollector
  17 from toscaparser.common.exception import MissingRequiredFieldError
  18 from toscaparser.common.exception import UnknownFieldError
  19 from toscaparser.dataentity import DataEntity
  20 from toscaparser.elements.constraints import Schema
  21 from toscaparser.elements.entity_type import EntityType
  22 from toscaparser.utils.gettextutils import _
  23 from org.openecomp.sdc.toscaparser.jython.parameters import JyInput
  24
  25
  26 log = logging.getLogger('tosca')
  27
  28
  29 class Input(JyInput):
  30
  31     INPUTFIELD = (TYPE, DESCRIPTION, DEFAULT, CONSTRAINTS, REQUIRED, STATUS,
  32                   ENTRY_SCHEMA) = ('type', 'description', 'default',
  33                                    'constraints', 'required', 'status',
  34                                    'entry_schema')
  35
  36     def __init__(self, name, schema_dict):
  37         self.name = name
  38         self.schema = Schema(name, schema_dict)
  39
  40         self._validate_field()
  41         self.validate_type(self.type)
  42
  43     def getJyName(self):
  44         return self.name
  45
  46     def getJyType(self):
  47         return self.name
  48
  49     def isJyRequired(self):
  50         return self.required
  51
  52     def getJyDescription(self):
  53         return self.description
  54
  55     def getJyDefault(self):
  56         return self.default
  57
  58     @property
  59     def type(self):
  60         return self.schema.type
  61
  62     @property
  63     def required(self):
  64         return self.schema.required
  65
  66     @property
  67     def description(self):
  68         return self.schema.description
  69
  70     @property
  71     def default(self):
  72         return self.schema.default
  73
  74     @property
  75     def constraints(self):
  76         return self.schema.constraints
  77
  78     @property
  79     def status(self):
  80         return self.schema.status
  81
  82     def validate(self, value=None):
  83         if value is not None:
  84             self._validate_value(value)
  85
  86     def _validate_field(self):
  87         for name in self.schema.schema:
  88             if name not in self.INPUTFIELD:
  89                 ExceptionCollector.appendException(
  90                     UnknownFieldError(what='Input "%s"' % self.name,
  91                                       field=name))
  92
  93     def validate_type(self, input_type):
  94         if input_type not in Schema.PROPERTY_TYPES:
  95             ExceptionCollector.appendException(
  96                 ValueError(_('Invalid type "%s".') % type))
  97
  98     # TODO(anyone) Need to test for any built-in datatype not just network
  99     # that is, tosca.datatypes.* and not assume tosca.datatypes.network.*
 100     # TODO(anyone) Add support for tosca.datatypes.Credential
 101     def _validate_value(self, value):
 102         tosca = EntityType.TOSCA_DEF
 103         datatype = None
 104         if self.type in tosca:
 105             datatype = tosca[self.type]
 106         elif EntityType.DATATYPE_NETWORK_PREFIX + self.type in tosca:
 107             datatype = tosca[EntityType.DATATYPE_NETWORK_PREFIX + self.type]
 108
 109         DataEntity.validate_datatype(self.type, value, None, datatype)
 110
 111
 112 class Output(object):
 113
 114     OUTPUTFIELD = (DESCRIPTION, VALUE) = ('description', 'value')
 115
 116     def __init__(self, name, attrs):
 117         self.name = name
 118         self.attrs = attrs
 119
 120     @property
 121     def description(self):
 122         return self.attrs.get(self.DESCRIPTION)
 123
 124     @property
 125     def value(self):
 126         return self.attrs.get(self.VALUE)
 127
 128     def validate(self):
 129         self._validate_field()
 130
 131     def _validate_field(self):
 132         if not isinstance(self.attrs, dict):
 133             ExceptionCollector.appendException(
 134                 MissingRequiredFieldError(what='Output "%s"' % self.name,
 135                                           required=self.VALUE))
 136         if self.value is None:
 137             ExceptionCollector.appendException(
 138                 MissingRequiredFieldError(what='Output "%s"' % self.name,
 139                                           required=self.VALUE))
 140         for name in self.attrs:
 141             if name not in self.OUTPUTFIELD:
 142                 ExceptionCollector.appendException(
 143                     UnknownFieldError(what='Output "%s"' % self.name,
 144                                       field=name))