def _to_volume(self, element, name=None): element_as = findall(element=element, xpath='attachmentSet/item', namespace=NAMESPACE) volume = {} for key in ['volumeId', 'size', 'createTime', 'status', 'attachmentSet']: volume[key] = findtext(element=element, xpath=key, namespace=NAMESPACE) if name is None: name = volume['volumeId'] svolume = StorageVolume(id=volume['volumeId'], name=name, size=int(volume['size']), driver=self) try: created_time = datetime.strptime(volume['createTime'], '%Y-%m-%dT%H:%M:%S.%fZ') except ValueError: # Wrong Format, try again.. created_time = datetime.strptime(volume['createTime'], '%Y-%m-%dT%H:%M:%SZ') svolume.extra = { 'createTime': created_time, 'status': volume['status'], 'attachmentSet': [self._get_attachment_set(element_as)]} return svolume
def setUp(self): ECSMockHttp.test = self ECSDriver.connectionCls.conn_class = ECSMockHttp ECSMockHttp.use_param = "Action" ECSMockHttp.type = None self.driver = ECSDriver(*ECS_PARAMS, region=self.region) self.fake_size = NodeSize( "ecs.t1.small", "ecs t1 small", None, None, None, None, self.driver ) self.fake_image = NodeImage( self.image_id, name="ubuntu 14.04 64bit", driver=self.driver ) self.fake_node = Node( id="fake-node1", name="fake-node", state=NodeState.RUNNING, public_ips=None, private_ips=None, driver=self.driver, ) self.fake_volume = StorageVolume( id="fake-volume1", name="fake-volume", size=self.fake_size, driver=self.driver, ) self.fake_snapshot = VolumeSnapshot(id="fake-snapshot1", driver=self.driver) self.fake_location = NodeLocation( id=self.region, name=self.region, country=None, driver=self.driver ) self.fake_instance_id = "fake_instance_id" self.fake_security_group_id = "fake_security_group_id"
def _to_volume(self, element, name): volId = findtext(element=element, xpath='volumeId', namespace=NAMESPACE) size = findtext(element=element, xpath='size', namespace=NAMESPACE) return StorageVolume(id=volId, name=name, size=int(size), driver=self)
def _to_volume(self, disk): extra = {'can_snapshot': disk['can_snapshot']} return StorageVolume(id=disk['id'], name=disk['name'], size=int(disk['size']), driver=self, extra=extra)
def _to_volume(self, storage): return StorageVolume( id=storage.findtext("ID"), name=storage.findtext("NAME"), size=int(storage.findtext("SIZE")), driver=self.connection.driver, )
def create_volume(self, size, name, location=None, snapshot=None): """ Creates a data volume Defaults to the first location """ for diskOffering in self.ex_list_disk_offerings(): if diskOffering.size == size or diskOffering.customizable: break else: raise LibcloudError('Disk offering with size=%s not found' % size) extraParams = dict() if diskOffering.customizable: extraParams['size'] = size if location is None: location = self.list_locations()[0] requestResult = self._async_request('createVolume', name=name, diskOfferingId=diskOffering.id, zoneId=location.id, **extraParams) volumeResponse = requestResult['volume'] return StorageVolume(id=volumeResponse['id'], name=name, size=size, driver=self, extra=dict(name=volumeResponse['name']))
def setUp(self): ECSMockHttp.test = self ECSDriver.connectionCls.conn_classes = (ECSMockHttp, ECSMockHttp) ECSMockHttp.use_param = 'Action' ECSMockHttp.type = None self.driver = ECSDriver(*ECS_PARAMS, region=self.region) self.fake_size = NodeSize('ecs.t1.small', 'ecs t1 small', None, None, None, None, self.driver) self.fake_image = NodeImage(self.image_id, name='ubuntu 14.04 64bit', driver=self.driver) self.fake_node = Node(id='fake-node1', name='fake-node', state=NodeState.RUNNING, public_ips=None, private_ips=None, driver=self.driver) self.fake_volume = StorageVolume(id='fake-volume1', name='fake-volume', size=self.fake_size, driver=self.driver) self.fake_snapshot = VolumeSnapshot(id='fake-snapshot1', driver=self.driver) self.fake_location = NodeLocation(id=self.region, name=self.region, country=None, driver=self.driver)
def create_volume(self, size, name, location, snapshot=None): # TODO Add snapshot handling for diskOffering in self.ex_list_disk_offerings(): if diskOffering.size == size or diskOffering.customizable: break else: raise LibcloudError('Disk offering with size=%s not found' % size) extraParams = dict() if diskOffering.customizable: extraParams['size'] = size requestResult = self._async_request('createVolume', name=name, diskOfferingId=diskOffering.id, zoneId=location.id, **extraParams) volumeResponse = requestResult['volume'] return StorageVolume(id=volumeResponse['id'], name=name, size=size, driver=self, extra=dict(name=volumeResponse['name']))
def _to_volume(self, element): """ Convert the json data to a Storage Volume Object :param element: json element :return: a Volume Object """ disk_id = element['id'] name = element['diskName'] state = CTYUN_VOLUME_STATE[element['diskStatus']] size = element['diskSize'] extra = { 'diskId': element['diskId'], 'isSysVolume': element['isSysVolume'], 'isPackaged': element['isPackaged'], 'status': CTYUN_VOLUME_STATE[str(element['status'])], 'applyDate': element['applyDate'], 'dueDate': element['dueDate'], 'vmName': element['vmName'], } return StorageVolume(id=disk_id, name=name, size=int(size), driver=self, state=state, extra=extra)
def create_volume(self, size, name, location=None, snapshot=None): """ Creates a new storage volume with the given size. The 'name' corresponds to the volume tag. The visibility of the created volume is 'private'. The snapshot parameter is currently ignored. The created StorageVolume contains a dict for the extra information with a 'location' key storing the location used for the volume. This is set to 'default' if no location has been given. @inherits: L{NodeDriver.create_volume} """ configHolder = self._get_config_section(location) pdisk = PersistentDisk(configHolder) # Creates a private disk. Boolean flag = False means private. vol_uuid = pdisk.createVolume(size, name, False) extra = {'location': location} return StorageVolume(vol_uuid, name, size, self, extra=extra)
def test_detach(self): vol = StorageVolume( id='vol-4282672b', name='test', size=10, driver=self.driver) retValue = self.driver.detach_volume(vol) self.assertTrue(retValue)
def test_base_storage_volume(self): StorageVolume( id="0", name="0", size=10, driver=FakeDriver(), state=StorageVolumeState.AVAILABLE, )
def test_attach(self): vol = StorageVolume(id='vol-4282672b', name='test', size=10, driver=self.driver) node = Node('i-4382922a', None, None, None, None, self.driver) retValue = self.driver.attach_volume(node, vol, '/dev/sdh') self.assertTrue(retValue)
def test_destroy_volume(self): # Will exception on failure node = self.driver.list_nodes()[0] volume = StorageVolume(id=55648, name="test", size=1024, driver=self.driver, extra={"LINODEID": node.id}) self.driver.destroy_volume(volume)
def _to_volume(self, obj): extra = obj.copy() extra.pop('id') extra.pop('name') extra.pop('size') state = self.VOLUME_STATE_MAP.get(obj.pop('status', None), StorageVolumeState.UNKNOWN) return StorageVolume(id=obj['id'], name=obj['name'], size=obj['size'], state=state, extra=extra, driver=self)
def _to_volume(self, disk): extra = {"can_snapshot": disk["can_snapshot"]} return StorageVolume( id=disk["id"], name=disk["name"], size=int(disk["size"]), driver=self, extra=extra, )
def _to_volume(self, data): extra = {'created_at': data['created_at'], 'droplet_ids': data['droplet_ids'], 'region': data['region'], 'region_slug': data['region']['slug']} return StorageVolume(id=data['id'], name=data['name'], size=data['size_gigabytes'], driver=self, extra=extra)
def test_create_volume_snapshot(self): vol = StorageVolume(id='vol-4282672b', name='test', size=10, driver=self.driver) snap = self.driver.create_volume_snapshot(vol, 'Test description') self.assertEqual('snap-a7cb2hd9', snap.id) self.assertEqual(vol.size, snap.size) self.assertEqual('Test description', snap.extra['description']) self.assertEqual(vol.id, snap.extra['volume_id']) self.assertEqual('pending', snap.extra['state'])
def _to_volume(self, volume): name = "" for tag in volume["Tags"]: if tag["Key"] == "Name": name = tag["Value"] return StorageVolume(id=volume["VolumeId"], name=name, size=volume["Size"], driver=self, state=volume["State"], extra=volume)
def _to_volume(self, volume): extra = { 'organization': volume['organization'], 'volume_type': volume['volume_type'], 'creation_date': parse_date(volume['creation_date']), 'modification_date': parse_date(volume['modification_date']), } return StorageVolume(id=volume['id'], name=volume['name'], size=_to_lib_size(volume['size']), driver=self, extra=extra)
def _to_volume(self, data): extra_keys = ['create_time', 'current_price', 'storage_type', 'relations'] extra = self._extract_values_to_dict(data=data, keys=extra_keys) storage = StorageVolume(id=data['object_uuid'], name=data['name'], size=data['capacity'], driver=self.connection.driver, extra=extra) return storage
def _to_volume(self, data): extra_keys = ["create_time", "current_price", "storage_type", "relations"] extra = self._extract_values_to_dict(data=data, keys=extra_keys) storage = StorageVolume( id=data["object_uuid"], name=data["name"], size=data["capacity"], driver=self.connection.driver, extra=extra, ) return storage
def _to_volume(self, object): # Converts an SCE Volume to a Libcloud StorageVolume extra = {'state': object.findtext('State'), 'location': object.findtext('Location'), 'instanceID': object.findtext('instanceID'), 'owner': object.findtext('Owner'), 'format': object.findtext('Format'), 'createdTime': object.findtext('CreatedTime'), 'storageAreaID': object.findtext('StorageArea/ID')} return StorageVolume(object.findtext('ID'), object.findtext('Name'), object.findtext('Size'), self.connection.driver, extra)
def list_volumes(self): """ List all volumes @rtype: C{list} of L{StorageVolume} """ list_volumes = [] volumes = self._sync_request('listVolumes') for vol in volumes['volume']: list_volumes.append(StorageVolume(id=vol['id'], name=vol['name'], size=vol['size'], driver=self)) return list_volumes
def __init__(self): # pylint: disable=W0231 self._TEST_SIZE = NodeSize( id="test_id", name="test_size", ram=4096, disk=10240, bandwidth=100000, price=0, driver=self, ) self._TEST_NODE = Node( id="test_id", name="test_node", state=NodeState.RUNNING, public_ips=["1.2.3.4"], private_ips=["2.3.4.5"], driver=self, size=self._TEST_SIZE, extra={"ex_key": "ex_value"}, ) self._TEST_LOCATION = NodeLocation(id="test_location", name="location1", country="Australia", driver=self) self._TEST_VOLUME = StorageVolume( id="vol1", name="vol_name", size=40960, driver=self, state=StorageVolumeState.AVAILABLE, extra={"ex_key": "ex_value"}, ) self._TEST_VOLUME_SNAPSHOT = VolumeSnapshot(id="snap1", size=80960, driver=self) self._TEST_IMAGE = NodeImage( id="image1", name="test_image", extra={"ex_key": "ex_value"}, driver=self, ) self._TEST_KEY_PAIR = KeyPair( name="test_key", fingerprint="abc123", public_key="pub123", private_key="priv123", driver=self, extra={"ex_key": "ex_value"}, )
def _to_volume(self, data): extra = { "created_at": data["created_at"], "droplet_ids": data["droplet_ids"], "region": data["region"], "region_slug": data["region"]["slug"], } return StorageVolume( id=data["id"], name=data["name"], size=data["size_gigabytes"], driver=self, extra=extra, )
def _to_volume(self, obj): extra = obj.copy() extra.pop("id") extra.pop("name") extra.pop("size") state = self.VOLUME_STATE_MAP.get( obj.pop("status", None), StorageVolumeState.UNKNOWN ) return StorageVolume( id=obj["id"], name=obj["name"], size=obj["size"], state=state, extra=extra, driver=self, )
def _to_volume(self, volume, node=None): ATTRIBUTE_NAME_MAP = { 'dataCenterId': 'datacenter_id', 'storageId': 'storage_id', 'storageName': 'storage_name', 'serverIds': 'server_id', 'creationTime': 'creation_time', 'lastModificationTime': 'last_modification_time', 'provisioningState': 'provisioning_state', 'size': 'size', } extra = {} for attribute_name, extra_name in ATTRIBUTE_NAME_MAP.items(): elem = volume.find(attribute_name) if ET.iselement(elem): value = elem.text else: value = None extra[extra_name] = value if ET.iselement(volume.find('mountImage')): image_id = volume.find('mountImage')[0].text image_name = volume.find('mountImage')[1].text else: image_id = None image_name = None extra['image_id'] = image_id extra['image_name'] = image_name extra['size'] = int(extra['size']) if extra['size'] else 0 extra['provisioning_state'] = \ self.PROVISIONING_STATE.get(extra['provisioning_state'], NodeState.UNKNOWN) storage_id = extra['storage_id'] storage_name = extra['storage_name'] size = extra['size'] return StorageVolume( id=storage_id, name=storage_name, size=size, driver=self.connection.driver, extra=extra)
def _to_volume(self, disk): """ Parse the XML element and return a StorageVolume object. :param name: An optional name for the volume. If not provided then either tag with a key "Name" or volume ID will be used (which ever is available first in that order). :type name: ``str`` :rtype: :class:`StorageVolume` """ return StorageVolume(id=disk['device']['key'], name=disk['label'], size=int(disk['capacity']), driver=self, extra=disk)
def _to_volumes(self, objs): """ Covert returned JSON volumes into StorageVolume instances :keyword objs: ``list`` of JSON dictionaries representing the StorageVolumes :type objs: ``list`` :return: ``list`` of :class:`StorageVolume`s """ volumes = {} for o in objs: vid = o["DISKID"] volumes[vid] = vol = StorageVolume(id=vid, name=o["LABEL"], size=int(o["SIZE"]), driver=self.connection.driver) vol.extra = copy(o) return list(volumes.values())