Esempio n. 1
0
    def execute(self):
        """Execute the action command."""
        args = self.arguments
        opts = self.options

        if not (TypeHelper.isKnownType(args[0])) and \
           ParseHelper.getXmlType(args[0]) == None:
            self.error(Messages.Error.NO_SUCH_TYPE % args[0])

        # scope = '%s:%s' % (ParseHelper.getXmlWrapperType(args[0]), args[2])
        actionable_types = TypeHelper.get_actionable_types(
            expendNestedTypes=True, groupOptions=True)

        resource = self.get_object(args[0],
                                   args[1],
                                   self.resolve_base(opts),
                                   context_variants=actionable_types[args[0]])

        if resource is None:
            self.error(Messages.Error.NO_SUCH_OBJECT % (args[0], args[1]))
        elif hasattr(resource, args[2]) and \
             type(getattr(resource, args[2])) == types.MethodType:
            try:
                result = self.execute_method(resource, args[2], opts)
            except Exception, e:
                self.error(str(e))
            if result.status.state == 'failed':
                self.error(Messages.Info.ACTION_STATUS % result.status.state)
Esempio n. 2
0
    def execute_method(self, resource, method_name, opts={}):
        """executes given method with specified opts."""

        if hasattr(resource, method_name):
            method = getattr(resource, method_name)

            method_args = OrderedDict().fromkeys(
                MethodHelper.getMethodArgs(brokers,
                                           method.im_class.__name__,
                                           method_name,
                                           drop_self=True))

            if method_args:
                for arg in method_args.keys():
                    param_type = ParseHelper.getXmlType(arg)
                    if param_type:
                        method_args[arg] = self.update_object_data(
                            param_type.factory(), opts)
                    elif opts.has_key('--' + arg):
                        method_args[arg] = opts['--' + arg]
                    else:
                        # TODO: throw error if param is mandatory
                        pass

                try:
                    result = method(**method_args)
                except AttributeError:
                    self.error(Messages.Error.UNSUPPORTED_ATTRIBUTE)
            else:
                result = method()
            return result
        else:
            self.error('no such action "%s"' % method_name)
Esempio n. 3
0
    def execute_method(self, resource, method_name, opts={}):
        """executes given method with specified opts."""

        if hasattr(resource, method_name):
            method = getattr(resource, method_name)

            method_args = OrderedDict().fromkeys(MethodHelper.getMethodArgs(brokers,
                                                                            method.im_class.__name__,
                                                                            method_name,
                                                                            drop_self=True))

            if method_args:
                for arg in method_args.keys():
                    param_type = ParseHelper.getXmlType(arg)
                    if param_type:
                        method_args[arg] = self.update_object_data(param_type.factory(), opts)
                    elif opts.has_key('--' + arg):
                        method_args[arg] = opts['--' + arg]
                    else:
                        # TODO: throw error if param is mandatory
                        pass

                try:
                    result = method(**method_args)
                except AttributeError:
                    self.error(Messages.Error.UNSUPPORTED_ATTRIBUTE)
            else:
                result = method()
            return result
        else:
            self.error('no such action "%s"' % method_name)
Esempio n. 4
0
 def add(self, vm, correlation_id=None, expect=None):
     url = '/api/vms'
     result = self.__getProxy().add(
             url=url,
             body=ParseHelper.toXml(vm),
             headers={"Correlation-Id":correlation_id, "Expect":expect})
    
     return VM(result, self.context)
Esempio n. 5
0
    def execute(self):
        """Execute the action command."""
        args = self.arguments
        opts = self.options

        if not (TypeHelper.isKnownType(args[0])) and \
           ParseHelper.getXmlType(args[0]) == None:
            self.error(
                       Messages.Error.NO_SUCH_TYPE % args[0]
            )

        # scope = '%s:%s' % (ParseHelper.getXmlWrapperType(args[0]), args[2])
        actionable_types = TypeHelper.get_actionable_types(
                       expendNestedTypes=True,
                       groupOptions=True
        )

        resource = self.get_object(
                       args[0],
                       args[1],
                       self.resolve_base(opts),
                       context_variants=actionable_types[args[0]]
        )

        if resource is None:
            self.error(
                   Messages.Error.NO_SUCH_OBJECT % (args[0], args[1])
            )
        elif hasattr(resource, args[2]) and \
             type(getattr(resource, args[2])) == types.MethodType:
            try:
                result = self.execute_method(resource, args[2], opts)
            except Exception, e:
                self.error(str(e))
            if result.status.state == 'failed':
                self.error(
                       Messages.Info.ACTION_STATUS % result.status.state
                )
Esempio n. 6
0
    def __do_set_data(self, obj, prop, fq_prop, val):
        """INTERNAL: set data in to object based on 'prop' map segmentation"""
        props = prop.split('-')
        props_len = len(props)
        if props_len > 1 or (props_len == 1 and hasattr(obj, prop)):
            for i in range(props_len):
                if props[i] == 'type': props[i] = 'type_'
                if i == (props_len - 1) and hasattr(
                        obj,
                        props[i]) and type(getattr(obj, props[i])) != list:
                    self.__set_property(obj, props[i], val, fq_prop)
                    return
                if hasattr(obj, props[i]) and type(getattr(obj,
                                                           props[i])) == list:
                    params_set_cand = ParseHelper.getXmlType(props[i])
                    if params_set_cand:
                        obj_params_set_cand = params_set_cand.factory()
                        root_obj_params_set_cand = obj_params_set_cand
                    else:
                        self.__do_set_primitive_list_data(obj, props[i], val)
                        return

                    if not val:
                        self.error(Messages.Error.
                                   INVALID_COLLECTION_BASED_OPTION_SYNTAX %
                                   prop)

                    for param in self.__split_with_escape(str(val),
                                                          delimiter=','):
                        obj_params_set_cand = root_obj_params_set_cand
                        if not param.startswith(props[i] + '.'):
                            self.error(
                                   Messages.Error.INVALID_OPTION_SEGMENT % \
                                   (param, prop)
                            )
                        param_data = param.replace(props[i] + '.',
                                                   '').split('=')
                        if len(param_data) == 2:
                            spplited_param_data = param_data[0].split('.')
                            for param_period in spplited_param_data:
                                if spplited_param_data[-1] == param_period:
                                    if not hasattr(obj_params_set_cand,
                                                   param_period):
                                        param_period = self.fixParamNameIfParamIsKeyword(
                                            param_period)
                                    if hasattr(obj_params_set_cand,
                                               param_period):
                                        if getattr(obj_params_set_cand,
                                                   param_period) != None:
                                            getattr(obj, props[i]).append(
                                                obj_params_set_cand)
                                            obj_params_set_cand = params_set_cand.factory(
                                            )
                                            root_obj_params_set_cand = obj_params_set_cand
                                        setattr(
                                            obj_params_set_cand, param_period,
                                            self.__try_parse(
                                                param_data[1].strip()))
                                    else:
                                        self.error(Messages.Error.INVALID_OPTION_SEGMENT % \
                                                   (param_period, param))
                                elif hasattr(obj_params_set_cand, param_period) and \
                                     getattr(obj_params_set_cand, param_period) == None:
                                    param_period_cand = ParseHelper.getXmlType(
                                        param_period)
                                    if param_period_cand:
                                        param_period_cand_obj = param_period_cand.factory(
                                        )
                                        setattr(obj_params_set_cand,
                                                param_period,
                                                param_period_cand_obj)
                                        obj_params_set_cand = param_period_cand_obj
                                elif hasattr(obj_params_set_cand,
                                             param_period):
                                    param_period_cand = ParseHelper.getXmlType(
                                        param_period)
                                    if param_period_cand:
                                        param_period_cand_obj = getattr(
                                            obj_params_set_cand, param_period)
                                        obj_params_set_cand = param_period_cand_obj
                                else:
                                    self.error(Messages.Error.INVALID_OPTION_SEGMENT % \
                                               (param_period, param))
                        else:
                            self.error(Messages.Error.
                                       INVALID_COLLECTION_BASED_OPTION_SYNTAX %
                                       prop)
                    getattr(obj, props[i]).append(obj_params_set_cand)
                elif hasattr(obj, props[i]):
                    content = getattr(obj, props[i])
                    if content is None:
                        cand1 = ParseHelper.getXmlType(props[i])
                        if cand1:
                            cand = cand1.factory()
                            setattr(obj, props[i], cand)
                            obj = cand
                    else:
                        obj = content
                else:
                    cand2 = ParseHelper.getXmlTypeInstance(props[i])
                    if cand2 and hasattr(obj, cand2):
                        cand1 = ParseHelper.getXmlType(cand2)
                        if cand1:
                            props[i] = cand2
                            cand = cand1.factory()
                            setattr(obj, props[i], cand)
                            obj = cand
                        else:
                            self.error(Messages.Error.NO_SUCH_TYPE % cand2)
                    else:
                        self.error(Messages.Error.INVALID_ARGUMENT_SEGMENT %
                                   props[i])
        else:
            self.__set_property(obj, prop, val, fq_prop)
Esempio n. 7
0
    def __do_set_data(self, obj, prop, fq_prop, val):
        """INTERNAL: set data in to object based on 'prop' map segmentation"""
        props = prop.split('-')
        props_len = len(props)
        if props_len > 1 or (props_len == 1 and hasattr(obj, prop)):
            for i in range(props_len):
                if props[i] == 'type': props[i] = 'type_'
                if i == (props_len - 1) and hasattr(obj, props[i]) and type(getattr(obj, props[i])) != list:
                    self.__set_property(obj, props[i], val, fq_prop)
                    return
                if hasattr(obj, props[i]) and type(getattr(obj, props[i])) == list:
                        params_set_cand = ParseHelper.getXmlType(props[i])
                        if params_set_cand:
                            obj_params_set_cand = params_set_cand.factory()
                            root_obj_params_set_cand = obj_params_set_cand
                        else:
                            self.__do_set_primitive_list_data(obj, props[i], val)
                            return

                        if not val:
                            self.error(Messages.Error.INVALID_COLLECTION_BASED_OPTION_SYNTAX % prop)

                        for param in self.__split_with_escape(str(val), delimiter=','):
                            obj_params_set_cand = root_obj_params_set_cand
                            if not param.startswith(props[i] + '.'):
                                self.error(
                                       Messages.Error.INVALID_OPTION_SEGMENT % \
                                       (param, prop)
                                )
                            param_data = param.replace(props[i] + '.', '').split('=')
                            if len(param_data) == 2:
                                spplited_param_data = param_data[0].split('.')
                                for param_period in spplited_param_data:
                                    if spplited_param_data[-1] == param_period:
                                        if not hasattr(obj_params_set_cand, param_period):
                                            param_period = self.fixParamNameIfParamIsKeyword(param_period)
                                        if hasattr(obj_params_set_cand, param_period):
                                            if getattr(obj_params_set_cand, param_period) != None:
                                                getattr(obj, props[i]).append(obj_params_set_cand)
                                                obj_params_set_cand = params_set_cand.factory()
                                                root_obj_params_set_cand = obj_params_set_cand
                                            setattr(obj_params_set_cand, param_period,
                                                    self.__try_parse(param_data[1].strip()))
                                        else:
                                            self.error(Messages.Error.INVALID_OPTION_SEGMENT % \
                                                       (param_period, param))
                                    elif hasattr(obj_params_set_cand, param_period) and \
                                         getattr(obj_params_set_cand, param_period) == None:
                                        param_period_cand = ParseHelper.getXmlType(param_period)
                                        if param_period_cand:
                                            param_period_cand_obj = param_period_cand.factory()
                                            setattr(obj_params_set_cand, param_period, param_period_cand_obj)
                                            obj_params_set_cand = param_period_cand_obj
                                    elif hasattr(obj_params_set_cand, param_period):
                                        param_period_cand = ParseHelper.getXmlType(param_period)
                                        if param_period_cand:
                                            param_period_cand_obj = getattr(obj_params_set_cand, param_period)
                                            obj_params_set_cand = param_period_cand_obj
                                    else:
                                        self.error(Messages.Error.INVALID_OPTION_SEGMENT % \
                                                   (param_period, param))
                            else:
                                self.error(Messages.Error.INVALID_COLLECTION_BASED_OPTION_SYNTAX % prop)
                        getattr(obj, props[i]).append(obj_params_set_cand)
                elif hasattr(obj, props[i]):
                    content = getattr(obj, props[i])
                    if content is None:
                        cand1 = ParseHelper.getXmlType(props[i])
                        if cand1:
                            cand = cand1.factory()
                            setattr(obj, props[i], cand)
                            obj = cand
                    else:
                        obj = content
                else:
                    cand2 = ParseHelper.getXmlTypeInstance(props[i])
                    if cand2 and hasattr(obj, cand2):
                        cand1 = ParseHelper.getXmlType(cand2)
                        if cand1:
                            props[i] = cand2
                            cand = cand1.factory()
                            setattr(obj, props[i], cand)
                            obj = cand
                        else:
                            self.error(Messages.Error.NO_SUCH_TYPE % cand2)
                    else:
                        self.error(Messages.Error.INVALID_ARGUMENT_SEGMENT % props[i])
        else:
            self.__set_property(obj, prop, val, fq_prop)