CiscoUcs/ucsmsdk

View on GitHub
ucsmsdk/ucsmethod.py

Summary

Maintainability
C
1 day
Test Coverage
# Copyright 2015 Cisco Systems, Inc.
#
# Licensed 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 prop
#  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.

"""
This module contains the UcsSdk Core classes.
"""

from __future__ import absolute_import
from .ucscore import UcsBase
from . import ucscoreutils
from . import ucsgenutils


try:
    import xml.etree.cElementTree as ET
    from xml.etree.cElementTree import Element, SubElement
except ImportError:
    import cElementTree as ET
    from cElementTree import Element, SubElement

import logging

log = logging.getLogger('ucs')


class ExternalMethod(UcsBase):
    """
    This class represents the UCS Central Xml api's query/configuration
    methods.
    """

    _external_method_attrs = {'errorCode': 'error_code',
                              'errorDescr': 'error_descr',
                              'invocationResult': 'invocation_result',
                              'response': 'response'}

    def __init__(self, method_id):
        # """ __init__ of the UcsBase class """
        UcsBase.__init__(self, method_id)

        meta_module = ucscoreutils.load_module(method_id)
        self.__method_meta = getattr(meta_module, "method_meta")
        self.__property_meta = getattr(meta_module, "prop_meta")
        self.__property_map = getattr(meta_module, "prop_map")

        # """ instantiate class variables """
        # for prop in CoreUtils.get_property_list(self._class_id):
        #     if prop != "Meta":
        #         self.__dict__[prop] = None
        for prop in self.__property_meta:
            self.__dict__[prop] = None

        self.error_code = 0
        self.error_descr = None
        self.invocation_result = None
        self.response = None
        self.mark_clean()

    def child_add(self, mo):
        """ This method adds child external method object to a
        external method object. """
        self._child.append(mo)

    def set_attr(self, key, value):
        """ This method sets the attribute of external method object."""
        if key in self.__property_meta:
            self.__dict__[key] = value
        elif key == 'error_code':
            self.error_code = value
        elif key == 'error_descr':
            self.error_descr = value
        elif key == 'invocation_result':
            self.invocation_result = value
        elif key == 'response':
            self.response = value
        else:
            # """ no such property """
            return None
            # raise AttributeError

    def get_error_response(self, error_code, error_descr):
        """ This methods sets error attributes of an external
         method object. """
        self.error_code = error_code
        self.error_descr = error_descr
        self.response = "yes"
        # return self

    def to_xml(self, xml_doc=None, option=None, elem_name=None):
        """ Method writes the xml representation of the external
        method object. """
        xml_obj = self.elem_create(
            class_tag=self.__method_meta.xml_attribute, xml_doc=xml_doc,
            override_tag=elem_name)

        for prop in self.__property_meta:
            if xml_obj.tag == "aaaLogout" and prop == "in_delay_secs" \
               and int(getattr(self, prop)) > 300:
                continue
            prop_meta = self.__property_meta[prop]
            if prop_meta.inp_out == "Output":
                continue
            if prop_meta.is_complex_type:
                if getattr(self, prop) is not None:
                    self.__dict__[prop].to_xml(xml_obj, option,
                                               prop_meta.xml_attribute)
            elif getattr(self, prop) is not None:
                xml_obj.set(prop_meta.xml_attribute, getattr(self, prop))

        self.child_to_xml(xml_obj, option)
        return xml_obj

    # , handle, modify_self=False, mo=None):
    def from_xml(self, elem, handle=None):
        """Method updates/fills the object from the xml representation
        of the external method object. """

        self._handle = handle
        if elem.attrib:
            for attr_name, attr_value in ucsgenutils.iteritems(elem.attrib):
                if attr_name in self.__property_map:
                    attr = self.__property_map[attr_name]
                    method_prop_meta = self.__property_meta[attr]
                    if method_prop_meta.inp_out == "Input" or (
                            method_prop_meta.is_complex_type):
                        continue
                    self.set_attr(attr, str(attr_value))
                elif attr_name in ExternalMethod._external_method_attrs:
                    self.set_attr(
                        ExternalMethod._external_method_attrs[attr_name],
                        str(attr_value))

        child_elems = elem.getchildren()
        if child_elems:
            for child_elem in child_elems:
                if not ET.iselement(child_elem):
                    continue
                child_name = child_elem.tag
                if child_name in self.__property_map:
                    child_name = self.__property_map[child_name]
                    method_prop_meta = self.__property_meta[
                        child_name]
                    if method_prop_meta.inp_out == "Output" and \
                            (method_prop_meta.is_complex_type):
                        child_obj = ucscoreutils.get_ucs_obj(
                            method_prop_meta.field_type,
                            child_elem)
                        if child_obj is not None:
                            self.set_attr(child_name,
                                          child_obj)
                            child_obj.from_xml(child_elem, handle)

    def __str__(self):
        tab_size = 8
        out_str = "\n"
        out_str += "External Method\t\t\t:\t" + str(self._class_id) + "\n"
        out_str += "-" * len("External Method") + "\n"
        for prop, prop_value in sorted(ucsgenutils.iteritems(self.__dict__)):
            if "ExternalMethod" in prop:
                continue
            out_str += str(prop).ljust(tab_size * 4) + ':' + str(
                prop_value) + "\n"

        return out_str