def new_value(self, value=b''): """ Create a new BlobValue :rtype: :class:`vmware.vapi.data.value.BlobValue` :return: Newly created BlobValue """ return data_value_factory(self.type, value)
def new_value(self, value=""): """ Create a new SecretValue :rtype: :class:`vmware.vapi.data.value.SecretValue` :return: Newly created SecretValue """ return data_value_factory(self.type, value)
def new_value(self): """ Create a new ErrorValue :rtype: :class:`vmware.vapi.data.value.ErrorValue` :return: Newly created ErrorValue """ return data_value_factory(self.type, self.name)
def new_value(self, value=False): """ Create a new BooleanValue :rtype: :class:`vmware.vapi.data.value.BooleanValue` :return: Newly created BooleanValue """ return data_value_factory(self.type, value)
def new_value(self, value=0.0): """ Create a new DoubleValue :rtype: :class:`vmware.vapi.data.value.DoubleValue` :return: Newly created DoubleValue """ return data_value_factory(self.type, value)
def new_value(self, value=0): """ Create a new IntegerValue :rtype: :class:`vmware.vapi.data.value.IntegerValue` :return: Newly created IntegerValue """ return data_value_factory(self.type, value)
def new_value(self): """ Create a new VoidValue :rtype: :class:`vmware.vapi.data.value.VoidValue` :return: Newly created VoidValue """ return data_value_factory(self.type)
def new_value(self, values=None): """ Create a new ListValue :type values: :class:`list` of :class:`vmware.vapi.data.value.DataValue` :param values: List of elements :rtype: :class:`vmware.vapi.data.value.ListValue` :return: Newly created ListValue """ return data_value_factory(self.type, values)
def new_value(self, value=None): """ Create and return a new :class:`OptionalValue` using this optional-definition. :type value: :class:`vmware.vapi.data.value.DataValue` :param value: The element value :rtype: :class:`vmware.vapi.data.value.OptionalValue` :return: A new optional value using the given data-definition """ return data_value_factory(self.type, value)
def visit_builtin(self, type_info, json_value): """ Deserialize a primitive value :type type_info: :class:`com.vmware.vapi.metadata.metamodel_client.Type` :param type_info: Metamodel type information :type json_value: :class:`object` :param json_value: Value to be visited :rtype: :class:`vmware.vapi.data.value.DataValue` :return: DataValue created using the input """ try: native_type = self._builtin_native_type_map[type_info.builtin_type] if native_type == six.text_type: if type_info.builtin_type == Type.BuiltinType.BINARY: # For Binary types, we need to convert unicode to bytes base64_encoded_value = json_value.encode() native_value = base64.b64decode(base64_encoded_value) else: native_value = json_value elif native_type == int: native_value = int(json_value) elif native_type == decimal.Decimal: native_value = decimal.Decimal(json_value) elif native_type == bool: if isinstance(json_value, bool): native_value = json_value elif json_value.lower() == 'true': native_value = True elif json_value.lower() == 'false': native_value = False else: msg = 'Expected boolean value, but got %s' % json_value logger.error(msg) raise werkzeug.exceptions.BadRequest(msg) data_type = self._builtin_type_map[type_info.builtin_type] return data_value_factory(data_type, native_value) except KeyError: msg = ('Could not process the request, ' 'builtin type %s is not supported' % type_info.builtin_type) logger.exception(msg) raise werkzeug.exceptions.InternalServerError(msg)
def data_value(value): """ get data value from new jsonrpc dict # TODO: Structure names and its fields are converted from # u'' format to str format. This will break if we allow non # ASCII characters in the IDL :type value: :class:`dict` :param value: json data value :rtype: subclass of :class:`vmware.vapi.data.value.DataValue` :return: subclass of data value """ result = None if value is None: result = data_value_factory(Type.VOID) elif isinstance(value, dict): # Optional, Secret, Blob, Error, Structure # types are inside object if len(value) > 1: raise vapi_jsonrpc_error_invalid_params() (type_name, json_value) = value.popitem() typ = json_to_vapi_map[type_name] if typ == Type.SECRET: result = data_value_factory(typ, json_value) elif typ == Type.BLOB: # For Blob types, the string json value will be base64 encoded # and UTF-8 decoded unicode_json_value = json_value base64_encoded_value = unicode_json_value.encode() try: bytes_value = base64.b64decode(base64_encoded_value) result = data_value_factory(typ, bytes_value) except Exception as err: if six.PY2 and isinstance(err, TypeError): raise vapi_jsonrpc_error_internal_error() elif six.PY3: import binascii if isinstance(err, binascii.Error): raise vapi_jsonrpc_error_internal_error() raise elif typ in [Type.ERROR, Type.STRUCTURE]: if len(json_value) > 1: raise vapi_jsonrpc_error_invalid_params() struct_name, fields = json_value.popitem() result = data_value_factory(typ, str(struct_name)) for field_name, field_value in six.iteritems(fields): field_data_value = JsonRpcDictToVapi.data_value( field_value) result.set_field(str(field_name), field_data_value) elif typ == Type.OPTIONAL: result = data_value_factory(typ) if json_value is not None: result.value = JsonRpcDictToVapi.data_value(json_value) elif isinstance(value, list): # ListValue is json list list_data_values = [ JsonRpcDictToVapi.data_value(val) for val in value ] result = data_value_factory(Type.LIST, list_data_values) elif isinstance(value, bool): result = data_value_factory(Type.BOOLEAN, value) elif isinstance(value, six.string_types): result = data_value_factory(Type.STRING, value) elif isinstance(value, six.integer_types): result = data_value_factory(Type.INTEGER, value) else: # For Double result = data_value_factory(Type.DOUBLE, value) return result