class Storage(object): """ Baseclass for storagesystem implementations. All supported methods should be implemented. If not an exception is raised. """ __logStrLevel__="Storage" log=ComLog.getLogger(__logStrLevel__) def getStorageObject(implementation, the_element): """ returns the storage object by the implementation attribute and the given element.""" module=__import__(implementation) for i in implementation.split(".")[1:]: module = getattr(module, i) if module: cls=None for key in module.__dict__.keys(): import inspect if inspect.isclass(getattr(module, key)) and inspect.getclasstree([getattr(module, key)], True)[0][0] == Storage: cls=getattr(module, key) break if cls: try: inst=object.__new__(cls) Storage.log.debug("class is %s" %(cls)) inst.__init__(element=the_element) connname=inst.getConnectionName() if not StorageConnections.has_key(connname): Storage.log.debug("Creating new storage connection %s %s" %(connname, StorageConnections.keys())) StorageConnections[connname]=inst return inst else: Storage.log.debug("Returning already established storage connection %s" %(connname)) return StorageConnections[connname] except: import traceback traceback.print_exc() raise IncompatibleObjectException(cls, Storage) else: raise IncompatibleObjectException(getattr(module, key), Storage) else: raise ModuleNotFoundException(implementation) getStorageObject=staticmethod(getStorageObject) def __init__(self, **kwds): """ Default constructor does nothing here. Except saving the parameters in attributes.""" self.system=self.username=self.password="" if kwds.has_key("system"): self.system=kwds["system"] if kwds.has_key("username"): self.username=kwds["username"] if kwds.has_key("password"): self.password=kwds["password"] if kwds.has_key("element"): self.fromElement(kwds["element"]) def fromElement(self, element): """ initializes Storage connection from element. First properties are read and then attributes in the element. Results to attributes precedence. """ from comoonics.ComProperties import Properties props=element.getElementsByTagName(Properties.TAGNAME) #log.debug("fromElement: %s, %u" %(element, len(props))) if len(props)>=1: self.properties=Properties(props[0]) for propertyname in self.properties.keys(): self.log.debug("fromElement: Setting attribute %s, %s" %(propertyname, self.properties[propertyname].getAttribute("value"))) setattr(self, propertyname, self.properties[propertyname].getAttribute("value")) for attribute in element.attributes: self.__dict__[attribute.name]=attribute.value # log.debug("fromElement: attribute(%s)=%s" %(attribute.name, getattr(self, attribute.name))) def getConnectionName(self): """ for singleton implementation if you want to have only one connection per storage system you can use this string as unique reference. Returns the self.system """ return self.system def isConnected(self): """ Returns True if this instance is already connected to the storagesystem or otherwise False. Default is False.""" return False def connect(self): """ Connects to the storage system """ raise NotImplementedYet() def map_luns(self, dest, source=None): """ Lunmaps the given disk. Hosts and luns are integrated insite the disk. """ raise NotImplementedYet() def unmap_luns(self, dest, source=None): """ Lunmaps the given disk (dest). Hosts and luns are integrated insite the disk. """ raise NotImplementedYet() def add(self, dest, source=None): """ Adds the given disk (dest). Parameters are packed as properties insite the disk. """ raise NotImplementedYet() def add_snapshot(self, dest, source=None): """ Snapshots the given sourcedisk to destdisk. Options are packed as properties insite of destdisk.""" raise NotImplementedYet() def add_clone(self, dest, source=None): """ Clones the given sourcedisk to destdisk. Options are packed as properties insite of destdisk. """ raise NotImplementedYet() def delete(self, dest, source=None): """ Deletes the given disk (dest). If you only want to support the deleting of snapshots use delete_snaphot. """ raise NotImplementedYet() def delete_snapshot(self, dest, source=None): """ Deletes the given disk (dest) only if its a snapshot. """ raise NotImplementedYet() def delete_clone(self, dest, source=None): """ Deletes the given disk(dest) only if its a clone. """ raise NotImplementedYet() def close(self): """ Cleans up and closes all open connections to the storagesystem """
class test_Properties(unittest.TestCase): def __init__(self, testMethod="runTest"): from comoonics import XmlTools super(test_Properties, self).__init__(testMethod) document=XmlTools.parseXMLString(xml_str) self.properties=Properties(document.documentElement, document) def test_str(self): self.assertEquals(str(self.properties), "Properties:{Property:{ testflag: }, Property:{ testname2: testvalue2}, Property:{ testname1: testvalue1}}") def test_str_property(self): self.assertEquals(str(self.properties["testname1"]), "Property:{ testname1: testvalue1}") def test_getProperty1(self): property_name="testname1" result1="testvalue1" result2=self.properties[property_name].getValue() self.assertEquals(result1, result2, "Property[%s]=%s != %s" %(property_name, result1, result2)) def test_getProperty2(self): property_name="testname2" result1="testvalue2" result2=self.properties[property_name].getValue() self.assertEquals(result1, result2, "Property[%s]=%s != %s" %(property_name, result1, result2)) def test_getProperty3(self): property_name="testflag" result1="" result2=self.properties[property_name].getValue() self.assertEquals(result1, result2, "Property[%s]=%s != %s" %(property_name, result1, result2)) def test_setProperty4(self): property_name="testname3" result1="testvalue3" self.properties[property_name]=result1 result2=self.properties[property_name].getValue() self.assertEquals(result1, result2, "Property[%s]=%s != %s" %(property_name, result1, result2)) def test_setProperty5(self): property_name="testflag2" result1=True self.properties[property_name]=result1 result2=self.properties[property_name].getValue() self.assertEquals("", result2, "Property[%s]=%s != %s" %(property_name, result1, result2)) def test_setProperty6(self): property_name="testname4" result1=True self.properties[property_name]=result1 result2=self.properties[property_name].getValue() self.assertEquals("", result2, "Property[%s]=%s != %s" %(property_name, result1, result2)) def test_getNonProperty(self): property_name="testname5" self.assertRaises(KeyError, self.properties.getAttribute, property_name) def test_keys(self): keys1=["testname1", "testname2", "testflag"] keys1.sort() keys2=self.properties.keys() keys2.sort() self.assertEquals(keys1, keys2, "self.properties.keys(): %s, expectedresult: %s" %(keys2, keys1)) def test_list(self): expected_result=["testname1=testvalue1", "testname2=testvalue2", "testflag="] expected_result.sort() result1=self.properties.list().split("\n") result1.sort() self.assertEquals(result1, expected_result, "self.properties.list(): %s\nexpectedresult: %s" %(result1, expected_result))
class test_Properties(unittest.TestCase): def __init__(self, testMethod="runTest"): from comoonics import XmlTools super(test_Properties, self).__init__(testMethod) document = XmlTools.parseXMLString(xml_str) self.properties = Properties(document.documentElement, document) def test_getProperty1(self): property_name = "testname1" result1 = "testvalue1" result2 = self.properties[property_name].getValue() self.assertEquals( result1, result2, "Property[%s]=%s != %s" % (property_name, result1, result2)) def test_getProperty2(self): property_name = "testname2" result1 = "testvalue2" result2 = self.properties[property_name].getValue() self.assertEquals( result1, result2, "Property[%s]=%s != %s" % (property_name, result1, result2)) def test_getProperty3(self): property_name = "testflag" result1 = "" result2 = self.properties[property_name].getValue() self.assertEquals( result1, result2, "Property[%s]=%s != %s" % (property_name, result1, result2)) def test_setProperty4(self): property_name = "testname3" result1 = "testvalue3" self.properties[property_name] = result1 result2 = self.properties[property_name].getValue() self.assertEquals( result1, result2, "Property[%s]=%s != %s" % (property_name, result1, result2)) def test_setProperty5(self): property_name = "testflag2" result1 = True self.properties[property_name] = result1 result2 = self.properties[property_name].getValue() self.assertEquals( "", result2, "Property[%s]=%s != %s" % (property_name, result1, result2)) def test_setProperty6(self): property_name = "testname4" result1 = True self.properties[property_name] = result1 result2 = self.properties[property_name].getValue() self.assertEquals( "", result2, "Property[%s]=%s != %s" % (property_name, result1, result2)) def test_getNonProperty(self): property_name = "testname5" self.assertRaises(KeyError, self.properties.getAttribute, property_name) def test_keys(self): keys1 = ["testname1", "testname2", "testflag"] keys1.sort() keys2 = self.properties.keys() keys2.sort() self.assertEquals( keys1, keys2, "self.properties.keys(): %s, expectedresult: %s" % (keys2, keys1)) def test_list(self): expected_result = [ "testname1=testvalue1", "testname2=testvalue2", "testflag=" ] expected_result.sort() result1 = self.properties.list().split("\n") result1.sort() self.assertEquals( result1, expected_result, "self.properties.list(): %s\nexpectedresult: %s" % (result1, expected_result))