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())
