You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@libcloud.apache.org by an...@apache.org on 2016/11/14 23:51:29 UTC
[42/56] [abbrv] libcloud git commit: Removed sdist
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/dimensiondata.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/dimensiondata.py b/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/dimensiondata.py
deleted file mode 100644
index fc83a55..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/dimensiondata.py
+++ /dev/null
@@ -1,688 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You 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 at
-#
-# 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.
-
-try:
- from lxml import etree as ET
-except ImportError:
- from xml.etree import ElementTree as ET
-
-from libcloud.backup.base import BackupDriver, BackupTarget, BackupTargetJob
-from libcloud.backup.types import BackupTargetType
-from libcloud.backup.types import Provider
-from libcloud.common.dimensiondata import dd_object_to_id
-from libcloud.common.dimensiondata import DimensionDataConnection
-from libcloud.common.dimensiondata import DimensionDataBackupClient
-from libcloud.common.dimensiondata import DimensionDataBackupClientAlert
-from libcloud.common.dimensiondata import DimensionDataBackupClientType
-from libcloud.common.dimensiondata import DimensionDataBackupDetails
-from libcloud.common.dimensiondata import DimensionDataBackupSchedulePolicy
-from libcloud.common.dimensiondata import DimensionDataBackupStoragePolicy
-from libcloud.common.dimensiondata import API_ENDPOINTS, DEFAULT_REGION
-from libcloud.common.dimensiondata import TYPES_URN
-from libcloud.common.dimensiondata import GENERAL_NS, BACKUP_NS
-from libcloud.utils.xml import fixxpath, findtext, findall
-
-DEFAULT_BACKUP_PLAN = 'Advanced'
-
-
-class DimensionDataBackupDriver(BackupDriver):
- """
- DimensionData backup driver.
- """
-
- selected_region = None
- connectionCls = DimensionDataConnection
- name = 'Dimension Data Backup'
- website = 'https://cloud.dimensiondata.com/'
- type = Provider.DIMENSIONDATA
- api_version = 1.0
-
- network_domain_id = None
-
- def __init__(self, key, secret=None, secure=True, host=None, port=None,
- api_version=None, region=DEFAULT_REGION, **kwargs):
-
- if region not in API_ENDPOINTS:
- raise ValueError('Invalid region: %s' % (region))
-
- self.selected_region = API_ENDPOINTS[region]
-
- super(DimensionDataBackupDriver, self).__init__(
- key=key, secret=secret,
- secure=secure, host=host,
- port=port,
- api_version=api_version,
- region=region,
- **kwargs)
-
- def _ex_connection_class_kwargs(self):
- """
- Add the region to the kwargs before the connection is instantiated
- """
-
- kwargs = super(DimensionDataBackupDriver,
- self)._ex_connection_class_kwargs()
- kwargs['region'] = self.selected_region
- return kwargs
-
- def get_supported_target_types(self):
- """
- Get a list of backup target types this driver supports
-
- :return: ``list`` of :class:``BackupTargetType``
- """
- return [BackupTargetType.VIRTUAL]
-
- def list_targets(self):
- """
- List all backuptargets
-
- :rtype: ``list`` of :class:`BackupTarget`
- """
- targets = self._to_targets(
- self.connection.request_with_orgId_api_2('server/server').object)
- return targets
-
- def create_target(self, name, address,
- type=BackupTargetType.VIRTUAL, extra=None):
- """
- Creates a new backup target
-
- :param name: Name of the target (not used)
- :type name: ``str``
-
- :param address: The ID of the node in Dimension Data Cloud
- :type address: ``str``
-
- :param type: Backup target type, only Virtual supported
- :type type: :class:`BackupTargetType`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- if extra is not None:
- service_plan = extra.get('servicePlan', DEFAULT_BACKUP_PLAN)
- else:
- service_plan = DEFAULT_BACKUP_PLAN
- extra = {'servicePlan': service_plan}
-
- create_node = ET.Element('NewBackup',
- {'xmlns': BACKUP_NS})
- create_node.set('servicePlan', service_plan)
-
- response = self.connection.request_with_orgId_api_1(
- 'server/%s/backup' % (address),
- method='POST',
- data=ET.tostring(create_node)).object
-
- asset_id = None
- for info in findall(response,
- 'additionalInformation',
- GENERAL_NS):
- if info.get('name') == 'assetId':
- asset_id = findtext(info, 'value', GENERAL_NS)
-
- return BackupTarget(
- id=asset_id,
- name=name,
- address=address,
- type=type,
- extra=extra,
- driver=self
- )
-
- def create_target_from_node(self, node, type=BackupTargetType.VIRTUAL,
- extra=None):
- """
- Creates a new backup target from an existing node
-
- :param node: The Node to backup
- :type node: ``Node``
-
- :param type: Backup target type (Physical, Virtual, ...).
- :type type: :class:`BackupTargetType`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- return self.create_target(name=node.name,
- address=node.id,
- type=BackupTargetType.VIRTUAL,
- extra=extra)
-
- def create_target_from_container(self, container,
- type=BackupTargetType.OBJECT,
- extra=None):
- """
- Creates a new backup target from an existing storage container
-
- :param node: The Container to backup
- :type node: ``Container``
-
- :param type: Backup target type (Physical, Virtual, ...).
- :type type: :class:`BackupTargetType`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- return NotImplementedError(
- 'create_target_from_container not supported for this driver')
-
- def update_target(self, target, name=None, address=None, extra=None):
- """
- Update the properties of a backup target, only changing the serviceplan
- is supported.
-
- :param target: Backup target to update
- :type target: Instance of :class:`BackupTarget` or ``str``
-
- :param name: Name of the target
- :type name: ``str``
-
- :param address: Hostname, FQDN, IP, file path etc.
- :type address: ``str``
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- if extra is not None:
- service_plan = extra.get('servicePlan', DEFAULT_BACKUP_PLAN)
- else:
- service_plan = DEFAULT_BACKUP_PLAN
- request = ET.Element('ModifyBackup',
- {'xmlns': BACKUP_NS})
- request.set('servicePlan', service_plan)
- server_id = self._target_to_target_address(target)
- self.connection.request_with_orgId_api_1(
- 'server/%s/backup/modify' % (server_id),
- method='POST',
- data=ET.tostring(request)).object
- if isinstance(target, BackupTarget):
- target.extra = extra
- else:
- target = self.ex_get_target_by_id(server_id)
- return target
-
- def delete_target(self, target):
- """
- Delete a backup target
-
- :param target: Backup target to delete
- :type target: Instance of :class:`BackupTarget` or ``str``
-
- :rtype: ``bool``
- """
- server_id = self._target_to_target_address(target)
- response = self.connection.request_with_orgId_api_1(
- 'server/%s/backup?disable' % (server_id),
- method='GET').object
- response_code = findtext(response, 'result', GENERAL_NS)
- return response_code in ['IN_PROGRESS', 'SUCCESS']
-
- def list_recovery_points(self, target, start_date=None, end_date=None):
- """
- List the recovery points available for a target
-
- :param target: Backup target to delete
- :type target: Instance of :class:`BackupTarget`
-
- :param start_date: The start date to show jobs between (optional)
- :type start_date: :class:`datetime.datetime`
-
- :param end_date: The end date to show jobs between (optional)
- :type end_date: :class:`datetime.datetime``
-
- :rtype: ``list`` of :class:`BackupTargetRecoveryPoint`
- """
- raise NotImplementedError(
- 'list_recovery_points not implemented for this driver')
-
- def recover_target(self, target, recovery_point, path=None):
- """
- Recover a backup target to a recovery point
-
- :param target: Backup target to delete
- :type target: Instance of :class:`BackupTarget`
-
- :param recovery_point: Backup target with the backup data
- :type recovery_point: Instance of :class:`BackupTarget`
-
- :param path: The part of the recovery point to recover (optional)
- :type path: ``str``
-
- :rtype: Instance of :class:`BackupTargetJob`
- """
- raise NotImplementedError(
- 'recover_target not implemented for this driver')
-
- def recover_target_out_of_place(self, target, recovery_point,
- recovery_target, path=None):
- """
- Recover a backup target to a recovery point out-of-place
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param recovery_point: Backup target with the backup data
- :type recovery_point: Instance of :class:`BackupTarget`
-
- :param recovery_target: Backup target with to recover the data to
- :type recovery_target: Instance of :class:`BackupTarget`
-
- :param path: The part of the recovery point to recover (optional)
- :type path: ``str``
-
- :rtype: Instance of :class:`BackupTargetJob`
- """
- raise NotImplementedError(
- 'recover_target_out_of_place not implemented for this driver')
-
- def get_target_job(self, target, id):
- """
- Get a specific backup job by ID
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param id: Backup target with the backup data
- :type id: Instance of :class:`BackupTarget`
-
- :rtype: :class:`BackupTargetJob`
- """
- jobs = self.list_target_jobs(target)
- return list(filter(lambda x: x.id == id, jobs))[0]
-
- def list_target_jobs(self, target):
- """
- List the backup jobs on a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :rtype: ``list`` of :class:`BackupTargetJob`
- """
- raise NotImplementedError(
- 'list_target_jobs not implemented for this driver')
-
- def create_target_job(self, target, extra=None):
- """
- Create a new backup job on a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTargetJob`
- """
- raise NotImplementedError(
- 'create_target_job not implemented for this driver')
-
- def resume_target_job(self, target, job):
- """
- Resume a suspended backup job on a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param job: Backup target job to resume
- :type job: Instance of :class:`BackupTargetJob`
-
- :rtype: ``bool``
- """
- raise NotImplementedError(
- 'resume_target_job not implemented for this driver')
-
- def suspend_target_job(self, target, job):
- """
- Suspend a running backup job on a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param job: Backup target job to suspend
- :type job: Instance of :class:`BackupTargetJob`
-
- :rtype: ``bool``
- """
- raise NotImplementedError(
- 'suspend_target_job not implemented for this driver')
-
- def cancel_target_job(self, job, ex_client=None, ex_target=None):
- """
- Cancel a backup job on a target
-
- :param job: Backup target job to cancel. If it is ``None``
- ex_client and ex_target must be set
- :type job: Instance of :class:`BackupTargetJob` or ``None``
-
- :param ex_client: Client of the job to cancel.
- Not necessary if job is specified.
- DimensionData only has 1 job per client
- :type ex_client: Instance of :class:`DimensionDataBackupClient`
- or ``str``
-
- :param ex_target: Target to cancel a job from.
- Not necessary if job is specified.
- :type ex_target: Instance of :class:`BackupTarget` or ``str``
-
- :rtype: ``bool``
- """
- if job is None:
- if ex_client is None or ex_target is None:
- raise ValueError("Either job or ex_client and "
- "ex_target have to be set")
- server_id = self._target_to_target_address(ex_target)
- client_id = self._client_to_client_id(ex_client)
- else:
- server_id = job.target.address
- client_id = job.extra['clientId']
-
- response = self.connection.request_with_orgId_api_1(
- 'server/%s/backup/client/%s?cancelJob' % (server_id,
- client_id),
- method='GET').object
- response_code = findtext(response, 'result', GENERAL_NS)
- return response_code in ['IN_PROGRESS', 'SUCCESS']
-
- def ex_get_target_by_id(self, id):
- """
- Get a target by server id
-
- :param id: The id of the target you want to get
- :type id: ``str``
-
- :rtype: :class:`BackupTarget`
- """
- node = self.connection.request_with_orgId_api_2(
- 'server/server/%s' % id).object
- return self._to_target(node)
-
- def ex_add_client_to_target(self, target, client_type, storage_policy,
- schedule_policy, trigger, email):
- """
- Add a client to a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget` or ``str``
-
- :param client: Client to add to the target
- :type client: Instance of :class:`DimensionDataBackupClientType`
- or ``str``
-
- :param storage_policy: The storage policy for the client
- :type storage_policy: Instance of
- :class:`DimensionDataBackupStoragePolicy`
- or ``str``
-
- :param schedule_policy: The schedule policy for the client
- :type schedule_policy: Instance of
- :class:`DimensionDataBackupSchedulePolicy`
- or ``str``
-
- :param trigger: The notify trigger for the client
- :type trigger: ``str``
-
- :param email: The notify email for the client
- :type email: ``str``
-
- :rtype: ``bool``
- """
- server_id = self._target_to_target_address(target)
-
- backup_elm = ET.Element('NewBackupClient',
- {'xmlns': BACKUP_NS})
- if isinstance(client_type, DimensionDataBackupClientType):
- ET.SubElement(backup_elm, "type").text = client_type.type
- else:
- ET.SubElement(backup_elm, "type").text = client_type
-
- if isinstance(storage_policy, DimensionDataBackupStoragePolicy):
- ET.SubElement(backup_elm,
- "storagePolicyName").text = storage_policy.name
- else:
- ET.SubElement(backup_elm,
- "storagePolicyName").text = storage_policy
-
- if isinstance(schedule_policy, DimensionDataBackupSchedulePolicy):
- ET.SubElement(backup_elm,
- "schedulePolicyName").text = schedule_policy.name
- else:
- ET.SubElement(backup_elm,
- "schedulePolicyName").text = schedule_policy
-
- alerting_elm = ET.SubElement(backup_elm, "alerting")
- alerting_elm.set('trigger', trigger)
- ET.SubElement(alerting_elm, "emailAddress").text = email
-
- response = self.connection.request_with_orgId_api_1(
- 'server/%s/backup/client' % (server_id),
- method='POST',
- data=ET.tostring(backup_elm)).object
- response_code = findtext(response, 'result', GENERAL_NS)
- return response_code in ['IN_PROGRESS', 'SUCCESS']
-
- def ex_remove_client_from_target(self, target, backup_client):
- """
- Removes a client from a backup target
-
- :param target: The backup target to remove the client from
- :type target: :class:`BackupTarget` or ``str``
-
- :param backup_client: The backup client to remove
- :type backup_client: :class:`DimensionDataBackupClient` or ``str``
-
- :rtype: ``bool``
- """
- server_id = self._target_to_target_address(target)
- client_id = self._client_to_client_id(backup_client)
- response = self.connection.request_with_orgId_api_1(
- 'server/%s/backup/client/%s?disable' % (server_id, client_id),
- method='GET').object
- response_code = findtext(response, 'result', GENERAL_NS)
- return response_code in ['IN_PROGRESS', 'SUCCESS']
-
- def ex_get_backup_details_for_target(self, target):
- """
- Returns a backup details object for a target
-
- :param target: The backup target to get details for
- :type target: :class:`BackupTarget` or ``str``
-
- :rtype: :class:`DimensionDataBackupDetails`
- """
- if not isinstance(target, BackupTarget):
- target = self.ex_get_target_by_id(target)
- response = self.connection.request_with_orgId_api_1(
- 'server/%s/backup' % (target.address),
- method='GET').object
- return self._to_backup_details(response, target)
-
- def ex_list_available_client_types(self, target):
- """
- Returns a list of available backup client types
-
- :param target: The backup target to list available types for
- :type target: :class:`BackupTarget` or ``str``
-
- :rtype: ``list`` of :class:`DimensionDataBackupClientType`
- """
- server_id = self._target_to_target_address(target)
- response = self.connection.request_with_orgId_api_1(
- 'server/%s/backup/client/type' % (server_id),
- method='GET').object
- return self._to_client_types(response)
-
- def ex_list_available_storage_policies(self, target):
- """
- Returns a list of available backup storage policies
-
- :param target: The backup target to list available policies for
- :type target: :class:`BackupTarget` or ``str``
-
- :rtype: ``list`` of :class:`DimensionDataBackupStoragePolicy`
- """
- server_id = self._target_to_target_address(target)
- response = self.connection.request_with_orgId_api_1(
- 'server/%s/backup/client/storagePolicy' % (server_id),
- method='GET').object
- return self._to_storage_policies(response)
-
- def ex_list_available_schedule_policies(self, target):
- """
- Returns a list of available backup schedule policies
-
- :param target: The backup target to list available policies for
- :type target: :class:`BackupTarget` or ``str``
-
- :rtype: ``list`` of :class:`DimensionDataBackupSchedulePolicy`
- """
- server_id = self._target_to_target_address(target)
- response = self.connection.request_with_orgId_api_1(
- 'server/%s/backup/client/schedulePolicy' % (server_id),
- method='GET').object
- return self._to_schedule_policies(response)
-
- def _to_storage_policies(self, object):
- elements = object.findall(fixxpath('storagePolicy', BACKUP_NS))
-
- return [self._to_storage_policy(el) for el in elements]
-
- def _to_storage_policy(self, element):
- return DimensionDataBackupStoragePolicy(
- retention_period=int(element.get('retentionPeriodInDays')),
- name=element.get('name'),
- secondary_location=element.get('secondaryLocation')
- )
-
- def _to_schedule_policies(self, object):
- elements = object.findall(fixxpath('schedulePolicy', BACKUP_NS))
-
- return [self._to_schedule_policy(el) for el in elements]
-
- def _to_schedule_policy(self, element):
- return DimensionDataBackupSchedulePolicy(
- name=element.get('name'),
- description=element.get('description')
- )
-
- def _to_client_types(self, object):
- elements = object.findall(fixxpath('backupClientType', BACKUP_NS))
-
- return [self._to_client_type(el) for el in elements]
-
- def _to_client_type(self, element):
- description = element.get('description')
- if description is None:
- description = findtext(element, 'description', BACKUP_NS)
- return DimensionDataBackupClientType(
- type=element.get('type'),
- description=description,
- is_file_system=bool(element.get('isFileSystem') == 'true')
- )
-
- def _to_backup_details(self, object, target):
- return DimensionDataBackupDetails(
- asset_id=object.get('assetId'),
- service_plan=object.get('servicePlan'),
- status=object.get('state'),
- clients=self._to_clients(object, target)
- )
-
- def _to_clients(self, object, target):
- elements = object.findall(fixxpath('backupClient', BACKUP_NS))
-
- return [self._to_client(el, target) for el in elements]
-
- def _to_client(self, element, target):
- client_id = element.get('id')
- return DimensionDataBackupClient(
- id=client_id,
- type=self._to_client_type(element),
- status=element.get('status'),
- schedule_policy=findtext(element, 'schedulePolicyName', BACKUP_NS),
- storage_policy=findtext(element, 'storagePolicyName', BACKUP_NS),
- download_url=findtext(element, 'downloadUrl', BACKUP_NS),
- running_job=self._to_backup_job(element, target, client_id),
- alert=self._to_alert(element)
- )
-
- def _to_alert(self, element):
- alert = element.find(fixxpath('alerting', BACKUP_NS))
- if alert is not None:
- notify_list = [
- email_addr.text for email_addr
- in alert.findall(fixxpath('emailAddress', BACKUP_NS))
- ]
- return DimensionDataBackupClientAlert(
- trigger=element.get('trigger'),
- notify_list=notify_list
- )
- return None
-
- def _to_backup_job(self, element, target, client_id):
- running_job = element.find(fixxpath('runningJob', BACKUP_NS))
- if running_job is not None:
- return BackupTargetJob(
- id=running_job.get('id'),
- status=running_job.get('status'),
- progress=int(running_job.get('percentageComplete')),
- driver=self.connection.driver,
- target=target,
- extra={'clientId': client_id}
- )
- return None
-
- def _to_targets(self, object):
- node_elements = object.findall(fixxpath('server', TYPES_URN))
-
- return [self._to_target(el) for el in node_elements]
-
- def _to_target(self, element):
- backup = findall(element, 'backup', TYPES_URN)
- if len(backup) == 0:
- return
- extra = {
- 'description': findtext(element, 'description', TYPES_URN),
- 'sourceImageId': findtext(element, 'sourceImageId', TYPES_URN),
- 'datacenterId': element.get('datacenterId'),
- 'deployedTime': findtext(element, 'createTime', TYPES_URN),
- 'servicePlan': backup[0].get('servicePlan')
- }
-
- n = BackupTarget(id=backup[0].get('assetId'),
- name=findtext(element, 'name', TYPES_URN),
- address=element.get('id'),
- driver=self.connection.driver,
- type=BackupTargetType.VIRTUAL,
- extra=extra)
- return n
-
- @staticmethod
- def _client_to_client_id(backup_client):
- return dd_object_to_id(backup_client, DimensionDataBackupClient)
-
- @staticmethod
- def _target_to_target_address(target):
- return dd_object_to_id(target, BackupTarget, id_value='address')
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/dummy.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/dummy.py b/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/dummy.py
deleted file mode 100644
index 2b28d66..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/dummy.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You 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 at
-#
-# 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.
-
-from libcloud.backup.base import BackupDriver
-
-
-class DummyBackupDriver(BackupDriver):
- """
- Dummy Backup driver.
-
- >>> from libcloud.backup.drivers.dummy import DummyBackupDriver
- >>> driver = DummyBackupDriver('key', 'secret')
- >>> driver.name
- 'Dummy Backup Provider'
- """
-
- name = 'Dummy Backup Provider'
- website = 'http://example.com'
-
- def __init__(self, api_key, api_secret):
- """
- :param api_key: API key or username to used (required)
- :type api_key: ``str``
-
- :param api_secret: Secret password to be used (required)
- :type api_secret: ``str``
-
- :rtype: ``None``
- """
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/ebs.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/ebs.py b/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/ebs.py
deleted file mode 100644
index fbeddb1..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/ebs.py
+++ /dev/null
@@ -1,413 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You 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 at
-#
-# 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.
-
-__all__ = [
- 'EBSBackupDriver'
-]
-
-
-from libcloud.utils.xml import findtext, findall
-from libcloud.utils.iso8601 import parse_date
-from libcloud.backup.base import BackupDriver, BackupTargetRecoveryPoint,\
- BackupTargetJob, BackupTarget
-from libcloud.backup.types import BackupTargetType, BackupTargetJobStatusType
-from libcloud.common.aws import AWSGenericResponse, SignedAWSConnection
-
-
-VERSION = '2015-10-01'
-HOST = 'ec2.amazonaws.com'
-ROOT = '/%s/' % (VERSION)
-NS = 'http://ec2.amazonaws.com/doc/%s/' % (VERSION, )
-
-
-class EBSResponse(AWSGenericResponse):
- """
- Amazon EBS response class.
- """
- namespace = NS
- exceptions = {}
- xpath = 'Error'
-
-
-class EBSConnection(SignedAWSConnection):
- version = VERSION
- host = HOST
- responseCls = EBSResponse
- service_name = 'backup'
-
-
-class EBSBackupDriver(BackupDriver):
- name = 'Amazon EBS Backup Driver'
- website = 'http://aws.amazon.com/ebs/'
- connectionCls = EBSConnection
-
- def __init__(self, access_id, secret, region):
- super(EBSBackupDriver, self).__init__(access_id, secret)
- self.region = region
- self.connection.host = HOST % (region)
-
- def get_supported_target_types(self):
- """
- Get a list of backup target types this driver supports
-
- :return: ``list`` of :class:``BackupTargetType``
- """
- return [BackupTargetType.VOLUME]
-
- def list_targets(self):
- """
- List all backuptargets
-
- :rtype: ``list`` of :class:`BackupTarget`
- """
- raise NotImplementedError(
- 'list_targets not implemented for this driver')
-
- def create_target(self, name, address,
- type=BackupTargetType.VOLUME, extra=None):
- """
- Creates a new backup target
-
- :param name: Name of the target
- :type name: ``str``
-
- :param address: The volume ID.
- :type address: ``str``
-
- :param type: Backup target type (Physical, Virtual, ...).
- :type type: :class:`BackupTargetType`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- # Does nothing since any volume can be snapped at anytime.
- return self.ex_get_target_by_volume_id(address)
-
- def create_target_from_node(self, node, type=BackupTargetType.VIRTUAL,
- extra=None):
- """
- Creates a new backup target from an existing node
-
- :param node: The Node to backup
- :type node: ``Node``
-
- :param type: Backup target type (Physical, Virtual, ...).
- :type type: :class:`BackupTargetType`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- # Get the first EBS volume.
- device_mapping = node.extra['block_device_mapping']
- if device_mapping is not None:
- return self.create_target(
- name=node.name,
- address=device_mapping['ebs'][0]['volume_id'],
- type=BackupTargetType.VOLUME,
- extra=None)
- else:
- raise RuntimeError("Node does not have any block devices")
-
- def create_target_from_container(self, container,
- type=BackupTargetType.OBJECT,
- extra=None):
- """
- Creates a new backup target from an existing storage container
-
- :param node: The Container to backup
- :type node: ``Container``
-
- :param type: Backup target type (Physical, Virtual, ...).
- :type type: :class:`BackupTargetType`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- raise NotImplementedError(
- 'create_target_from_container not implemented for this driver')
-
- def update_target(self, target, name, address, extra):
- """
- Update the properties of a backup target
-
- :param target: Backup target to update
- :type target: Instance of :class:`BackupTarget`
-
- :param name: Name of the target
- :type name: ``str``
-
- :param address: Hostname, FQDN, IP, file path etc.
- :type address: ``str``
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- # Does nothing since any volume can be snapped at anytime.
- return self.ex_get_target_by_volume_id(address)
-
- def delete_target(self, target):
- """
- Delete a backup target
-
- :param target: Backup target to delete
- :type target: Instance of :class:`BackupTarget`
- """
- raise NotImplementedError(
- 'delete_target not implemented for this driver')
-
- def list_recovery_points(self, target, start_date=None, end_date=None):
- """
- List the recovery points available for a target
-
- :param target: Backup target to delete
- :type target: Instance of :class:`BackupTarget`
-
- :param start_date: The start date to show jobs between (optional)
- :type start_date: :class:`datetime.datetime`
-
- :param end_date: The end date to show jobs between (optional)
- :type end_date: :class:`datetime.datetime``
-
- :rtype: ``list`` of :class:`BackupTargetRecoveryPoint`
- """
- params = {
- 'Action': 'DescribeSnapshots',
- 'Filter.1.Name': 'volume-id',
- 'Filter.1.Value': target.extra['volume-id']
- }
- data = self.connection.request(ROOT, params=params).object
- return self._to_recovery_points(data, target)
-
- def recover_target(self, target, recovery_point, path=None):
- """
- Recover a backup target to a recovery point
-
- :param target: Backup target to delete
- :type target: Instance of :class:`BackupTarget`
-
- :param recovery_point: Backup target with the backup data
- :type recovery_point: Instance of :class:`BackupTarget`
-
- :param path: The part of the recovery point to recover (optional)
- :type path: ``str``
-
- :rtype: Instance of :class:`BackupTargetJob`
- """
- raise NotImplementedError(
- 'delete_target not implemented for this driver')
-
- def recover_target_out_of_place(self, target, recovery_point,
- recovery_target, path=None):
- """
- Recover a backup target to a recovery point out-of-place
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param recovery_point: Backup target with the backup data
- :type recovery_point: Instance of :class:`BackupTarget`
-
- :param recovery_target: Backup target with to recover the data to
- :type recovery_target: Instance of :class:`BackupTarget`
-
- :param path: The part of the recovery point to recover (optional)
- :type path: ``str``
-
- :rtype: Instance of :class:`BackupTargetJob`
- """
- raise NotImplementedError(
- 'delete_target not implemented for this driver')
-
- def get_target_job(self, target, id):
- """
- Get a specific backup job by ID
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param id: Backup target with the backup data
- :type id: Instance of :class:`BackupTarget`
-
- :rtype: :class:`BackupTargetJob`
- """
- jobs = self.list_target_jobs(target)
- return list(filter(lambda x: x.id == id, jobs))[0]
-
- def list_target_jobs(self, target):
- """
- List the backup jobs on a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :rtype: ``list`` of :class:`BackupTargetJob`
- """
- params = {
- 'Action': 'DescribeSnapshots',
- 'Filter.1.Name': 'volume-id',
- 'Filter.1.Value': target.extra['volume-id'],
- 'Filter.2.Name': 'status',
- 'Filter.2.Value': 'pending'
- }
- data = self.connection.request(ROOT, params=params).object
- return self._to_jobs(data)
-
- def create_target_job(self, target, extra=None):
- """
- Create a new backup job on a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTargetJob`
- """
- params = {
- 'Action': 'CreateSnapshot',
- 'VolumeId': target.extra['volume-id']
- }
- data = self.connection.request(ROOT, params=params).object
- xpath = 'CreateSnapshotResponse'
- return self._to_job(findall(element=data,
- xpath=xpath, namespace=NS)[0])
-
- def resume_target_job(self, job):
- """
- Resume a suspended backup job on a target
-
- :param job: Backup target job to resume
- :type job: Instance of :class:`BackupTargetJob`
-
- :rtype: ``bool``
- """
- raise NotImplementedError(
- 'resume_target_job not supported for this driver')
-
- def suspend_target_job(self, job):
- """
- Suspend a running backup job on a target
-
- :param job: Backup target job to suspend
- :type job: Instance of :class:`BackupTargetJob`
-
- :rtype: ``bool``
- """
- raise NotImplementedError(
- 'suspend_target_job not supported for this driver')
-
- def cancel_target_job(self, job):
- """
- Cancel a backup job on a target
-
- :param job: Backup target job to cancel
- :type job: Instance of :class:`BackupTargetJob`
-
- :rtype: ``bool``
- """
- raise NotImplementedError(
- 'cancel_target_job not supported for this driver')
-
- def _to_recovery_points(self, data, target):
- xpath = 'DescribeSnapshotsResponse/snapshotSet/item'
- return [self._to_recovery_point(el, target)
- for el in findall(element=data, xpath=xpath, namespace=NS)]
-
- def _to_recovery_point(self, el, target):
- id = findtext(element=el, xpath='snapshotId', namespace=NS)
- date = parse_date(
- findtext(element=el, xpath='startTime', namespace=NS))
- tags = self._get_resource_tags(el)
- point = BackupTargetRecoveryPoint(
- id=id,
- date=date,
- target=target,
- driver=self.connection.driver,
- extra={
- 'snapshot-id': id,
- 'tags': tags
- },
- )
- return point
-
- def _to_jobs(self, data):
- xpath = 'DescribeSnapshotsResponse/snapshotSet/item'
- return [self._to_job(el)
- for el in findall(element=data, xpath=xpath, namespace=NS)]
-
- def _to_job(self, el):
- id = findtext(element=el, xpath='snapshotId', namespace=NS)
- progress = findtext(element=el, xpath='progress', namespace=NS)\
- .replace('%', '')
- volume_id = findtext(element=el, xpath='volumeId', namespace=NS)
- target = self.ex_get_target_by_volume_id(volume_id)
- job = BackupTargetJob(
- id=id,
- status=BackupTargetJobStatusType.PENDING,
- progress=int(progress),
- target=target,
- driver=self.connection.driver,
- extra={
- },
- )
- return job
-
- def ex_get_target_by_volume_id(self, volume_id):
- return BackupTarget(
- id=volume_id,
- name=volume_id,
- address=volume_id,
- type=BackupTargetType.VOLUME,
- driver=self.connection.driver,
- extra={
- "volume-id": volume_id
- }
- )
-
- def _get_resource_tags(self, element):
- """
- Parse tags from the provided element and return a dictionary with
- key/value pairs.
-
- :rtype: ``dict``
- """
- tags = {}
-
- # Get our tag set by parsing the element
- tag_set = findall(element=element,
- xpath='tagSet/item',
- namespace=NS)
-
- for tag in tag_set:
- key = findtext(element=tag,
- xpath='key',
- namespace=NS)
-
- value = findtext(element=tag,
- xpath='value',
- namespace=NS)
-
- tags[key] = value
-
- return tags
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/gce.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/gce.py b/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/gce.py
deleted file mode 100644
index 151f734..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/backup/drivers/gce.py
+++ /dev/null
@@ -1,478 +0,0 @@
-
-
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You 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 at
-#
-# 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.
-
-__all__ = [
- 'GCEBackupDriver'
-]
-
-from libcloud.utils.iso8601 import parse_date
-from libcloud.backup.base import BackupDriver, BackupTargetRecoveryPoint,\
- BackupTargetJob, BackupTarget
-from libcloud.backup.types import BackupTargetType, BackupTargetJobStatusType
-
-from libcloud.common.google import GoogleResponse, GoogleBaseConnection
-
-API_VERSION = 'v1'
-DEFAULT_TASK_COMPLETION_TIMEOUT = 180
-
-
-class GCEResponse(GoogleResponse):
- pass
-
-
-class GCEConnection(GoogleBaseConnection):
- """
- Connection class for the GCE driver.
-
- GCEConnection extends :class:`google.GoogleBaseConnection` for 2 reasons:
- 1. modify request_path for GCE URI.
- 2. Implement gce_params functionality described below.
-
- If the parameter gce_params is set to a dict prior to calling request(),
- the URL parameters will be updated to include those key/values FOR A
- SINGLE REQUEST. If the response contains a nextPageToken,
- gce_params['pageToken'] will be set to its value. This can be used to
- implement paging in list:
-
- >>> params, more_results = {'maxResults': 2}, True
- >>> while more_results:
- ... driver.connection.gce_params=params
- ... driver.ex_list_urlmaps()
- ... more_results = 'pageToken' in params
- ...
- [<GCEUrlMap id="..." name="cli-map">, <GCEUrlMap id="..." name="lc-map">]
- [<GCEUrlMap id="..." name="web-map">]
- """
- host = 'www.googleapis.com'
- responseCls = GCEResponse
-
- def __init__(self, user_id, key, secure, auth_type=None,
- credential_file=None, project=None, **kwargs):
- super(GCEConnection, self).__init__(user_id, key, secure=secure,
- auth_type=auth_type,
- credential_file=credential_file,
- **kwargs)
- self.request_path = '/compute/%s/projects/%s' % (API_VERSION,
- project)
- self.gce_params = None
-
- def pre_connect_hook(self, params, headers):
- """
- Update URL parameters with values from self.gce_params.
-
- @inherits: :class:`GoogleBaseConnection.pre_connect_hook`
- """
- params, headers = super(GCEConnection, self).pre_connect_hook(params,
- headers)
- if self.gce_params:
- params.update(self.gce_params)
- return params, headers
-
- def request(self, *args, **kwargs):
- """
- Perform request then do GCE-specific processing of URL params.
-
- @inherits: :class:`GoogleBaseConnection.request`
- """
- response = super(GCEConnection, self).request(*args, **kwargs)
-
- # If gce_params has been set, then update the pageToken with the
- # nextPageToken so it can be used in the next request.
- if self.gce_params:
- if 'nextPageToken' in response.object:
- self.gce_params['pageToken'] = response.object['nextPageToken']
- elif 'pageToken' in self.gce_params:
- del self.gce_params['pageToken']
- self.gce_params = None
-
- return response
-
-
-class GCEBackupDriver(BackupDriver):
- name = 'Google Compute Engine Backup Driver'
- website = 'http://cloud.google.com/'
- connectionCls = GCEConnection
-
- def __init__(self, user_id, key=None, project=None,
- auth_type=None, scopes=None, credential_file=None, **kwargs):
- """
- :param user_id: The email address (for service accounts) or Client ID
- (for installed apps) to be used for authentication.
- :type user_id: ``str``
-
- :param key: The RSA Key (for service accounts) or file path containing
- key or Client Secret (for installed apps) to be used for
- authentication.
- :type key: ``str``
-
- :keyword project: Your GCE project name. (required)
- :type project: ``str``
-
- :keyword auth_type: Accepted values are "SA" or "IA" or "GCE"
- ("Service Account" or "Installed Application" or
- "GCE" if libcloud is being used on a GCE instance
- with service account enabled).
- If not supplied, auth_type will be guessed based
- on value of user_id or if the code is being
- executed in a GCE instance.
- :type auth_type: ``str``
-
- :keyword scopes: List of authorization URLs. Default is empty and
- grants read/write to Compute, Storage, DNS.
- :type scopes: ``list``
-
- :keyword credential_file: Path to file for caching authentication
- information used by GCEConnection.
- :type credential_file: ``str``
- """
- if not project:
- raise ValueError('Project name must be specified using '
- '"project" keyword.')
-
- self.auth_type = auth_type
- self.project = project
- self.scopes = scopes
- self.credential_file = credential_file or \
- '~/.gce_libcloud_auth' + '.' + self.project
-
- super(GCEBackupDriver, self).__init__(user_id, key, **kwargs)
-
- # Cache Zone and Region information to reduce API calls and
- # increase speed
- self.base_path = '/compute/%s/projects/%s' % (API_VERSION,
- self.project)
-
- def get_supported_target_types(self):
- """
- Get a list of backup target types this driver supports
-
- :return: ``list`` of :class:``BackupTargetType``
- """
- return [BackupTargetType.VOLUME]
-
- def list_targets(self):
- """
- List all backuptargets
-
- :rtype: ``list`` of :class:`BackupTarget`
- """
- raise NotImplementedError(
- 'list_targets not implemented for this driver')
-
- def create_target(self, name, address,
- type=BackupTargetType.VOLUME, extra=None):
- """
- Creates a new backup target
-
- :param name: Name of the target
- :type name: ``str``
-
- :param address: The volume ID.
- :type address: ``str``
-
- :param type: Backup target type (Physical, Virtual, ...).
- :type type: :class:`BackupTargetType`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- # Does nothing since any volume can be snapped at anytime.
- return self.ex_get_target_by_source(address)
-
- def create_target_from_node(self, node, type=BackupTargetType.VIRTUAL,
- extra=None):
- """
- Creates a new backup target from an existing node
-
- :param node: The Node to backup
- :type node: ``Node``
-
- :param type: Backup target type (Physical, Virtual, ...).
- :type type: :class:`BackupTargetType`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- # Get the first persistent disk
- disks = node.extra['disks']
- if disks is not None:
- return self.create_target(
- name=node.name,
- address=disks[0]['source'],
- type=BackupTargetType.VOLUME,
- extra=None)
- else:
- raise RuntimeError("Node does not have any block devices")
-
- def create_target_from_container(self, container,
- type=BackupTargetType.OBJECT,
- extra=None):
- """
- Creates a new backup target from an existing storage container
-
- :param node: The Container to backup
- :type node: ``Container``
-
- :param type: Backup target type (Physical, Virtual, ...).
- :type type: :class:`BackupTargetType`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- raise NotImplementedError(
- 'create_target_from_container not implemented for this driver')
-
- def update_target(self, target, name, address, extra):
- """
- Update the properties of a backup target
-
- :param target: Backup target to update
- :type target: Instance of :class:`BackupTarget`
-
- :param name: Name of the target
- :type name: ``str``
-
- :param address: Hostname, FQDN, IP, file path etc.
- :type address: ``str``
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTarget`
- """
- # Does nothing since any volume can be snapped at anytime.
- return self.ex_get_target_by_source(address)
-
- def delete_target(self, target):
- """
- Delete a backup target
-
- :param target: Backup target to delete
- :type target: Instance of :class:`BackupTarget`
- """
- raise NotImplementedError(
- 'delete_target not implemented for this driver')
-
- def list_recovery_points(self, target, start_date=None, end_date=None):
- """
- List the recovery points available for a target
-
- :param target: Backup target to delete
- :type target: Instance of :class:`BackupTarget`
-
- :param start_date: The start date to show jobs between (optional)
- :type start_date: :class:`datetime.datetime`
-
- :param end_date: The end date to show jobs between (optional)
- :type end_date: :class:`datetime.datetime``
-
- :rtype: ``list`` of :class:`BackupTargetRecoveryPoint`
- """
- request = '/global/snapshots'
- response = self.connection.request(request, method='GET').object
- return self._to_recovery_points(response, target)
-
- def recover_target(self, target, recovery_point, path=None):
- """
- Recover a backup target to a recovery point
-
- :param target: Backup target to delete
- :type target: Instance of :class:`BackupTarget`
-
- :param recovery_point: Backup target with the backup data
- :type recovery_point: Instance of :class:`BackupTarget`
-
- :param path: The part of the recovery point to recover (optional)
- :type path: ``str``
-
- :rtype: Instance of :class:`BackupTargetJob`
- """
- raise NotImplementedError(
- 'recover_target not implemented for this driver')
-
- def recover_target_out_of_place(self, target, recovery_point,
- recovery_target, path=None):
- """
- Recover a backup target to a recovery point out-of-place
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param recovery_point: Backup target with the backup data
- :type recovery_point: Instance of :class:`BackupTarget`
-
- :param recovery_target: Backup target with to recover the data to
- :type recovery_target: Instance of :class:`BackupTarget`
-
- :param path: The part of the recovery point to recover (optional)
- :type path: ``str``
-
- :rtype: Instance of :class:`BackupTargetJob`
- """
- raise NotImplementedError(
- 'recover_target_out_of_place not implemented for this driver')
-
- def get_target_job(self, target, id):
- """
- Get a specific backup job by ID
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param id: Backup target with the backup data
- :type id: Instance of :class:`BackupTarget`
-
- :rtype: :class:`BackupTargetJob`
- """
- jobs = self.list_target_jobs(target)
- return list(filter(lambda x: x.id == id, jobs))[0]
-
- def list_target_jobs(self, target):
- """
- List the backup jobs on a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :rtype: ``list`` of :class:`BackupTargetJob`
- """
- return []
-
- def create_target_job(self, target, extra=None):
- """
- Create a new backup job on a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param extra: (optional) Extra attributes (driver specific).
- :type extra: ``dict``
-
- :rtype: Instance of :class:`BackupTargetJob`
- """
- name = target.name
- request = '/zones/%s/disks/%s/createSnapshot' % (
- target.extra['zone'].name, target.name)
- snapshot_data = {
- 'source': target.extra['source']
- }
- self.connection.async_request(request, method='POST',
- data=snapshot_data)
- return self._to_job(self.ex_get_snapshot(name), target)
-
- def resume_target_job(self, target, job):
- """
- Resume a suspended backup job on a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param job: Backup target job to resume
- :type job: Instance of :class:`BackupTargetJob`
-
- :rtype: ``bool``
- """
- raise NotImplementedError(
- 'resume_target_job not supported for this driver')
-
- def suspend_target_job(self, target, job):
- """
- Suspend a running backup job on a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param job: Backup target job to suspend
- :type job: Instance of :class:`BackupTargetJob`
-
- :rtype: ``bool``
- """
- raise NotImplementedError(
- 'suspend_target_job not supported for this driver')
-
- def cancel_target_job(self, target, job):
- """
- Cancel a backup job on a target
-
- :param target: Backup target with the backup data
- :type target: Instance of :class:`BackupTarget`
-
- :param job: Backup target job to cancel
- :type job: Instance of :class:`BackupTargetJob`
-
- :rtype: ``bool``
- """
- raise NotImplementedError(
- 'cancel_target_job not supported for this driver')
-
- def _to_recovery_points(self, data, target):
- return [self._to_recovery_point(item, target)
- for item in data.items]
-
- def _to_recovery_point(self, item, target):
- id = item.id
- date = parse_date(item.creationTimestamp)
- point = BackupTargetRecoveryPoint(
- id=id,
- date=date,
- target=target,
- driver=self.connection.driver,
- extra={
- 'snapshot-id': id,
- },
- )
- return point
-
- def _to_jobs(self, data, target):
- return [self._to_job(item, target)
- for item in data.items]
-
- def _to_job(self, item, target):
- id = item.id
- job = BackupTargetJob(
- id=id,
- status=BackupTargetJobStatusType.PENDING,
- progress=0,
- target=target,
- driver=self.connection.driver,
- extra={
- },
- )
- return job
-
- def ex_get_snapshot(self, name):
- request = '/global/snapshots/%s' % (name)
- response = self.connection.request(request, method='GET').object
- return response
-
- def ex_get_target_by_source(self, source):
- return BackupTarget(
- id=source,
- name=source,
- address=source,
- type=BackupTargetType.VOLUME,
- driver=self.connection.driver,
- extra={
- "source": source
- }
- )
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/backup/providers.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/backup/providers.py b/apache-libcloud-1.0.0rc2/libcloud/backup/providers.py
deleted file mode 100644
index 16cd610..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/backup/providers.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You 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 at
-#
-# 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.
-
-from libcloud.backup.types import Provider
-from libcloud.common.providers import get_driver as _get_provider_driver
-from libcloud.common.providers import set_driver as _set_provider_driver
-
-DRIVERS = {
- Provider.DUMMY:
- ('libcloud.backup.drivers.dummy', 'DummyBackupDriver'),
- Provider.EBS:
- ('libcloud.backup.drivers.ebs', 'EBSBackupDriver'),
- Provider.GCE:
- ('libcloud.backup.drivers.gce', 'GCEBackupDriver'),
- Provider.DIMENSIONDATA:
- ('libcloud.backup.drivers.dimensiondata', 'DimensionDataBackupDriver')
-}
-
-
-def get_driver(provider):
- return _get_provider_driver(drivers=DRIVERS, provider=provider)
-
-
-def set_driver(provider, module, klass):
- return _set_provider_driver(drivers=DRIVERS, provider=provider,
- module=module, klass=klass)
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/backup/types.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/backup/types.py b/apache-libcloud-1.0.0rc2/libcloud/backup/types.py
deleted file mode 100644
index 0264268..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/backup/types.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You 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 at
-#
-# 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.
-
-__all__ = [
- 'Provider',
- 'BackupTargetType',
- 'BackupTargetJobStatusType'
-]
-
-
-class Provider(object):
- DUMMY = 'dummy'
- EBS = 'ebs'
- GCE = 'gce'
- DIMENSIONDATA = 'dimensiondata'
-
-
-class BackupTargetType(object):
- """
- Backup Target type.
- """
-
- VIRTUAL = 'Virtual'
- """ Denotes a virtual host """
-
- PHYSICAL = 'Physical'
- """ Denotes a physical host """
-
- FILESYSTEM = 'Filesystem'
- """ Denotes a file system (e.g. NAS) """
-
- DATABASE = 'Database'
- """ Denotes a database target """
-
- OBJECT = 'Object'
- """ Denotes an object based file system """
-
- VOLUME = 'Volume'
- """ Denotes a block storage volume """
-
-
-class BackupTargetJobStatusType(object):
- """
- The status of a backup target job
- """
-
- RUNNING = 'Running'
- CANCELLED = 'Cancelled'
- FAILED = 'Failed'
- COMPLETED = 'Completed'
- PENDING = 'Pending'
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/__init__.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/__init__.py b/apache-libcloud-1.0.0rc2/libcloud/common/__init__.py
deleted file mode 100644
index e69de29..0000000
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/abiquo.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/abiquo.py b/apache-libcloud-1.0.0rc2/libcloud/common/abiquo.py
deleted file mode 100644
index a972243..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/abiquo.py
+++ /dev/null
@@ -1,274 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You 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 at
-#
-# 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.
-"""
-Abiquo Utilities Module for the Abiquo Driver.
-
-Common utilities needed by the :class:`AbiquoNodeDriver`.
-"""
-import base64
-
-from libcloud.common.base import ConnectionUserAndKey, PollingConnection
-from libcloud.common.base import XmlResponse
-from libcloud.common.types import InvalidCredsError, LibcloudError
-from libcloud.utils.py3 import httplib
-from libcloud.utils.py3 import urlparse
-from libcloud.utils.py3 import b
-from libcloud.compute.base import NodeState
-
-
-def get_href(element, rel):
- """
- Search a RESTLink element in the :class:`AbiquoResponse`.
-
- Abiquo, as a REST API, it offers self-discovering functionality.
- That means that you could walk through the whole API only
- navigating from the links offered by the entities.
-
- This is a basic method to find the 'relations' of an entity searching into
- its links.
-
- For instance, a Rack entity serialized as XML as the following::
-
- <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
- <rack>
- <link href="http://host/api/admin/datacenters/1"
- type="application/vnd.abiquo.datacenter+xml" rel="datacenter"/>
- <link href="http://host/api/admin/datacenters/1/racks/1"
- type="application/vnd.abiquo.rack+xml" rel="edit"/>
- <link href="http://host/api/admin/datacenters/1/racks/1/machines"
- type="application/vnd.abiquo.machines+xml" rel="machines"/>
- <haEnabled>false</haEnabled>
- <id>1</id>
- <longDescription></longDescription>
- <name>racacaca</name>
- <nrsq>10</nrsq>
- <shortDescription></shortDescription>
- <vlanIdMax>4094</vlanIdMax>
- <vlanIdMin>2</vlanIdMin>
- <vlanPerVdcReserved>1</vlanPerVdcReserved>
- <vlansIdAvoided></vlansIdAvoided>
- </rack>
-
- offers link to datacenters (rel='datacenter'), to itself (rel='edit') and
- to the machines defined in it (rel='machines')
-
- A call to this method with the 'rack' element using 'datacenter' as 'rel'
- will return:
-
- 'http://10.60.12.7:80/api/admin/datacenters/1'
-
- :type element: :class:`xml.etree.ElementTree`
- :param element: Xml Entity returned by Abiquo API (required)
- :type rel: ``str``
- :param rel: relation link name
- :rtype: ``str``
- :return: the 'href' value according to the 'rel' input parameter
- """
- links = element.findall('link')
- for link in links:
- if link.attrib['rel'] == rel:
- href = link.attrib['href']
- # href is something like:
- #
- # 'http://localhost:80/api/admin/enterprises'
- #
- # we are only interested in '/admin/enterprises/' part
- needle = '/api/'
- url_path = urlparse.urlparse(href).path
- index = url_path.find(needle)
- result = url_path[index + len(needle) - 1:]
- return result
-
-
-class AbiquoResponse(XmlResponse):
- """
- Abiquo XML Response.
-
- Wraps the response in XML bodies or extract the error data in
- case of error.
- """
-
- # Map between abiquo state and Libcloud State
- NODE_STATE_MAP = {
- 'NOT_ALLOCATED': NodeState.TERMINATED,
- 'ALLOCATED': NodeState.PENDING,
- 'CONFIGURED': NodeState.PENDING,
- 'ON': NodeState.RUNNING,
- 'PAUSED': NodeState.PENDING,
- 'OFF': NodeState.PENDING,
- 'LOCKED': NodeState.PENDING,
- 'UNKNOWN': NodeState.UNKNOWN
- }
-
- def parse_error(self):
- """
- Parse the error messages.
-
- Response body can easily be handled by this class parent
- :class:`XmlResponse`, but there are use cases which Abiquo API
- does not respond an XML but an HTML. So we need to
- handle these special cases.
- """
- if self.status == httplib.UNAUTHORIZED:
- raise InvalidCredsError(driver=self.connection.driver)
- elif self.status == httplib.FORBIDDEN:
- raise ForbiddenError(self.connection.driver)
- elif self.status == httplib.NOT_ACCEPTABLE:
- raise LibcloudError('Not Acceptable')
- else:
- parsebody = self.parse_body()
- if parsebody is not None and hasattr(parsebody, 'findall'):
- errors = self.parse_body().findall('error')
- # Most of the exceptions only have one error
- raise LibcloudError(errors[0].findtext('message'))
- else:
- raise LibcloudError(self.body)
-
- def success(self):
- """
- Determine if the request was successful.
-
- Any of the 2XX HTTP response codes are accepted as successful requests
-
- :rtype: ``bool``
- :return: successful request or not.
- """
- return self.status in [httplib.OK, httplib.CREATED, httplib.NO_CONTENT,
- httplib.ACCEPTED]
-
- def async_success(self):
- """
- Determinate if async request was successful.
-
- An async_request retrieves for a task object that can be successfully
- retrieved (self.status == OK), but the asynchronous task (the body of
- the HTTP response) which we are asking for has finished with an error.
- So this method checks if the status code is 'OK' and if the task
- has finished successfully.
-
- :rtype: ``bool``
- :return: successful asynchronous request or not
- """
- if self.success():
- # So we have a 'task' object in the body
- task = self.parse_body()
- return task.findtext('state') == 'FINISHED_SUCCESSFULLY'
- else:
- return False
-
-
-class AbiquoConnection(ConnectionUserAndKey, PollingConnection):
- """
- A Connection to Abiquo API.
-
- Basic :class:`ConnectionUserAndKey` connection with
- :class:`PollingConnection` features for asynchronous tasks.
- """
-
- responseCls = AbiquoResponse
-
- def __init__(self, user_id, key, secure=True, host=None, port=None,
- url=None, timeout=None,
- retry_delay=None, backoff=None, proxy_url=None):
- super(AbiquoConnection, self).__init__(user_id=user_id, key=key,
- secure=secure,
- host=host, port=port,
- url=url, timeout=timeout,
- retry_delay=retry_delay,
- backoff=backoff,
- proxy_url=proxy_url)
-
- # This attribute stores data cached across multiple request
- self.cache = {}
-
- def add_default_headers(self, headers):
- """
- Add Basic Authentication header to all the requests.
-
- It injects the 'Authorization: Basic Base64String===' header
- in each request
-
- :type headers: ``dict``
- :param headers: Default input headers
-
- :rtype: ``dict``
- :return: Default input headers with the 'Authorization'
- header
- """
- b64string = b('%s:%s' % (self.user_id, self.key))
- encoded = base64.b64encode(b64string).decode('utf-8')
-
- authorization = 'Basic ' + encoded
-
- headers['Authorization'] = authorization
- return headers
-
- def get_poll_request_kwargs(self, response, context, request_kwargs):
- """
- Manage polling request arguments.
-
- Return keyword arguments which are passed to the
- :class:`NodeDriver.request` method when polling for the job status. The
- Abiquo Asynchronous Response returns and 'acceptedrequest' XmlElement
- as the following::
-
- <acceptedrequest>
- <link href="http://uri/to/task" rel="status"/>
- <message>You can follow the progress in the link</message>
- </acceptedrequest>
-
- We need to extract the href URI to poll.
-
- :type response: :class:`xml.etree.ElementTree`
- :keyword response: Object returned by poll request.
- :type request_kwargs: ``dict``
- :keyword request_kwargs: Default request arguments and headers
- :rtype: ``dict``
- :return: Modified keyword arguments
- """
- accepted_request_obj = response.object
- link_poll = get_href(accepted_request_obj, 'status')
- hdr_poll = {'Accept': 'application/vnd.abiquo.task+xml'}
-
- # Override the 'action', 'method' and 'headers'
- # keys of the previous dict
- request_kwargs['action'] = link_poll
- request_kwargs['method'] = 'GET'
- request_kwargs['headers'] = hdr_poll
- return request_kwargs
-
- def has_completed(self, response):
- """
- Decide if the asynchronous job has ended.
-
- :type response: :class:`xml.etree.ElementTree`
- :param response: Response object returned by poll request
- :rtype: ``bool``
- :return: Whether the job has completed
- """
- task = response.object
- task_state = task.findtext('state')
- return task_state in ['FINISHED_SUCCESSFULLY', 'ABORTED',
- 'FINISHED_UNSUCCESSFULLY']
-
-
-class ForbiddenError(LibcloudError):
- """
- Exception used when credentials are ok but user has not permissions.
- """
-
- def __init__(self, driver):
- message = 'User has not permission to perform this task.'
- super(LibcloudError, self).__init__(message, driver)
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/aliyun.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/aliyun.py b/apache-libcloud-1.0.0rc2/libcloud/common/aliyun.py
deleted file mode 100644
index 4e91dbb..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/aliyun.py
+++ /dev/null
@@ -1,239 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You 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 at
-#
-# 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.
-
-import base64
-import hashlib
-import hmac
-import sys
-import time
-import uuid
-
-try:
- from lxml import etree as ET
-except ImportError:
- from xml.etree import ElementTree as ET
-
-from libcloud.common.base import ConnectionUserAndKey, XmlResponse
-from libcloud.common.types import MalformedResponseError
-from libcloud.utils.py3 import b, u, urlquote, PY3
-from libcloud.utils.xml import findtext
-
-__all__ = [
- 'AliyunXmlResponse',
- 'AliyunRequestSigner',
- 'AliyunRequestSignerAlgorithmV1_0',
- 'SignedAliyunConnection',
- 'AliyunConnection',
-
- 'SIGNATURE_VERSION_1_0',
- 'DEFAULT_SIGNATURE_VERSION'
-]
-
-SIGNATURE_VERSION_1_0 = '1.0'
-DEFAULT_SIGNATURE_VERSION = SIGNATURE_VERSION_1_0
-
-
-class AliyunXmlResponse(XmlResponse):
- namespace = None
-
- def success(self):
- return self.status >= 200 and self.status < 300
-
- def parse_body(self):
- """
- Each response from Aliyun contains a request id and a host id.
- The response body is in utf-8 encoding.
- """
- if len(self.body) == 0 and not self.parse_zero_length_body:
- return self.body
-
- try:
- if PY3:
- parser = ET.XMLParser(encoding='utf-8')
- body = ET.XML(self.body.encode('utf-8'), parser=parser)
- else:
- body = ET.XML(self.body)
- except:
- raise MalformedResponseError('Failed to parse XML',
- body=self.body,
- driver=self.connection.driver)
- self.request_id = findtext(element=body, xpath='RequestId',
- namespace=self.namespace)
- self.host_id = findtext(element=body, xpath='HostId',
- namespace=self.namespace)
- return body
-
- def parse_error(self):
- """
- Parse error responses from Aliyun.
- """
- body = super(AliyunXmlResponse, self).parse_error()
- code, message = self._parse_error_details(element=body)
- request_id = findtext(element=body, xpath='RequestId',
- namespace=self.namespace)
- host_id = findtext(element=body, xpath='HostId',
- namespace=self.namespace)
- error = {'code': code,
- 'message': message,
- 'request_id': request_id,
- 'host_id': host_id}
- return u(error)
-
- def _parse_error_details(self, element):
- """
- Parse error code and message from the provided error element.
-
- :return: ``tuple`` with two elements: (code, message)
- :rtype: ``tuple``
- """
- code = findtext(element=element, xpath='Code',
- namespace=self.namespace)
- message = findtext(element=element, xpath='Message',
- namespace=self.namespace)
-
- return (code, message)
-
-
-class AliyunRequestSigner(object):
- """
- Class handles signing the outgoing Aliyun requests.
- """
-
- def __init__(self, access_key, access_secret, version):
- """
- :param access_key: Access key.
- :type access_key: ``str``
-
- :param access_secret: Access secret.
- :type access_secret: ``str``
-
- :param version: API version.
- :type version: ``str``
- """
- self.access_key = access_key
- self.access_secret = access_secret
- self.version = version
-
- def get_request_params(self, params, method='GET', path='/'):
- return params
-
- def get_request_headers(self, params, headers, method='GET', path='/'):
- return params, headers
-
-
-class AliyunRequestSignerAlgorithmV1_0(AliyunRequestSigner):
- """Aliyun request signer using signature version 1.0."""
- def get_request_params(self, params, method='GET', path='/'):
- params['Format'] = 'XML'
- params['Version'] = self.version
- params['AccessKeyId'] = self.access_key
- params['SignatureMethod'] = 'HMAC-SHA1'
- params['SignatureVersion'] = SIGNATURE_VERSION_1_0
- params['SignatureNonce'] = _get_signature_nonce()
- # TODO: Support 'ResourceOwnerAccount'
- params['Timestamp'] = time.strftime('%Y-%m-%dT%H:%M:%SZ',
- time.gmtime())
- params['Signature'] = self._sign_request(params, method, path)
- return params
-
- def _sign_request(self, params, method, path):
- """
- Sign Aliyun requests parameters and get the signature.
-
- StringToSign = HTTPMethod + '&' +
- percentEncode('/') + '&' +
- percentEncode(CanonicalizedQueryString)
- """
- keys = list(params.keys())
- keys.sort()
- pairs = []
- for key in keys:
- pairs.append('%s=%s' % (_percent_encode(key),
- _percent_encode(params[key])))
- qs = urlquote('&'.join(pairs), safe='-_.~')
- string_to_sign = '&'.join((method, urlquote(path, safe=''), qs))
- b64_hmac = base64.b64encode(
- hmac.new(b(self._get_access_secret()), b(string_to_sign),
- digestmod=hashlib.sha1).digest()
- )
-
- return b64_hmac.decode('utf8')
-
- def _get_access_secret(self):
- return '%s&' % self.access_secret
-
-
-class AliyunConnection(ConnectionUserAndKey):
- pass
-
-
-class SignedAliyunConnection(AliyunConnection):
- def __init__(self, user_id, key, secure=True, host=None, port=None,
- url=None, timeout=None, proxy_url=None, retry_delay=None,
- backoff=None, signature_version=DEFAULT_SIGNATURE_VERSION):
- super(SignedAliyunConnection, self).__init__(user_id=user_id, key=key,
- secure=secure,
- host=host, port=port,
- url=url, timeout=timeout,
- proxy_url=proxy_url,
- retry_delay=retry_delay,
- backoff=backoff)
- self.signature_version = str(signature_version)
-
- if self.signature_version == '1.0':
- signer_cls = AliyunRequestSignerAlgorithmV1_0
- else:
- raise ValueError('Unsupported signature_version: %s' %
- signature_version)
-
- self.signer = signer_cls(access_key=self.user_id,
- access_secret=self.key,
- version=self.version)
-
- def add_default_params(self, params):
- params = self.signer.get_request_params(params=params,
- method=self.method,
- path=self.action)
- return params
-
-
-def _percent_encode(encode_str):
- """
- Encode string to utf8, quote for url and replace '+' with %20,
- '*' with %2A and keep '~' not converted.
-
- :param src_str: ``str`` in the same encoding with sys.stdin,
- default to encoding cp936.
- :return: ``str`` represents the encoded result
- :rtype: ``str``
- """
- encoding = sys.stdin.encoding or 'cp936'
- decoded = str(encode_str)
- if PY3:
- if isinstance(encode_str, bytes):
- decoded = encode_str.decode(encoding)
- else:
- decoded = str(encode_str).decode(encoding)
-
- res = urlquote(
- decoded.encode('utf8'), '')
- res = res.replace('+', '%20')
- res = res.replace('*', '%2A')
- res = res.replace('%7E', '~')
- return res
-
-
-def _get_signature_nonce():
- return str(uuid.uuid4())