libcloud-notifications mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From anthonys...@apache.org
Subject [36/56] [abbrv] libcloud git commit: Removed sdist
Date Mon, 14 Nov 2016 23:51:23 GMT
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/abiquo.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/abiquo.py b/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/abiquo.py
deleted file mode 100644
index fdcc59d..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/abiquo.py
+++ /dev/null
@@ -1,795 +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 Compute Driver
-
-The driver implements the compute Abiquo functionality for the Abiquo API.
-This version is compatible with the following versions of Abiquo:
-
-    * Abiquo 3.1 (http://wiki.abiquo.com/display/ABI31/The+Abiquo+API)
-"""
-import xml.etree.ElementTree as ET
-
-from libcloud.compute.base import NodeDriver, NodeSize
-from libcloud.compute.types import Provider, LibcloudError
-from libcloud.common.abiquo import (AbiquoConnection, get_href,
-                                    AbiquoResponse)
-from libcloud.compute.base import NodeLocation, NodeImage, Node
-from libcloud.utils.py3 import tostring
-
-
-class AbiquoNodeDriver(NodeDriver):
-    """
-    Implements the :class:`NodeDriver`'s for the Abiquo Compute Provider
-    """
-
-    type = Provider.ABIQUO
-    name = 'Abiquo'
-    website = 'http://www.abiquo.com/'
-    connectionCls = AbiquoConnection
-    timeout = 2000  # some images take a lot of time!
-
-    # Media Types
-    NODES_MIME_TYPE = 'application/vnd.abiquo.virtualmachines+xml'
-    NODE_MIME_TYPE = 'application/vnd.abiquo.virtualmachine+xml'
-    VAPPS_MIME_TYPE = 'application/vnd.abiquo.virtualappliances+xml'
-    VAPP_MIME_TYPE = 'application/vnd.abiquo.virtualappliance+xml'
-    VM_TASK_MIME_TYPE = 'application/vnd.abiquo.virtualmachinetask+xml'
-    USER_MIME_TYPE = 'application/vnd.abiquo.user+xml'
-    ENT_MIME_TYPE = 'application/vnd.abiquo.enterprise+xml'
-    VDCS_MIME_TYPE = 'application/vnd.abiquo.virtualdatacenters+xml'
-    VDC_MIME_TYPE = 'application/vnd.abiquo.virtualdatacenter+xml'
-    DCS_MIME_TYPE = 'application/vnd.abiquo.datacenters+xml'
-    VMTPLS_MIME_TYPE = 'application/vnd.abiquo.virtualmachinetemplates+xml'
-    VMTPL_MIME_TYPE = 'application/vnd.abiquo.virtualmachinetemplate+xml'
-    NICS_MIME_TYPE = 'application/vnd.abiquo.nics+xml'
-    DCRS_MIME_TYPE = 'application/vnd.abiquo.datacenterrepositories+xml'
-    DCR_MIME_TYPE = 'application/vnd.abiquo.datacenterrepository+xml'
-    AR_MIME_TYPE = 'application/vnd.abiquo.acceptedrequest+xml'
-
-    # Others constants
-    GIGABYTE = 1073741824
-
-    def __init__(self, user_id, secret, endpoint, **kwargs):
-        """
-        Initializes Abiquo Driver
-
-        Initializes the :class:`NodeDriver` object and populate the cache.
-
-        :param       user_id: identifier of Abiquo user (required)
-        :type        user_id: ``str``
-        :param       secret: password of the Abiquo user (required)
-        :type        secret: ``str``
-        :param       endpoint: Abiquo API endpoint (required)
-        :type        endpoint: ``str`` that can be parsed as URL
-        """
-        self.endpoint = endpoint
-        super(AbiquoNodeDriver, self).__init__(key=user_id, secret=secret,
-                                               secure=False, host=None,
-                                               port=None, **kwargs)
-        self.ex_populate_cache()
-
-    def create_node(self, **kwargs):
-        """
-        Create a new node instance in Abiquo
-
-        All the :class:`Node`s need to be defined inside a VirtualAppliance
-        (called :class:`NodeGroup` here). If there is no group name defined,
-        'libcloud' name will be used instead.
-
-        This method wraps these Abiquo actions:
-
-            1. Create a group if it does not exist.
-            2. Register a new node in the group.
-            3. Deploy the node and boot it.
-            4. Retrieves it again to get schedule-time attributes (such as ips
-               and vnc ports).
-
-        The rest of the driver methods has been created in a way that, if any
-        of these actions fail, the user can not reach an inconsistent state
-
-        :keyword    name:   The name for this new node (required)
-        :type       name:   ``str``
-
-        :keyword    size:   The size of resources allocated to this node.
-        :type       size:   :class:`NodeSize`
-
-        :keyword    image:  OS Image to boot on node. (required)
-        :type       image:  :class:`NodeImage`
-
-        :keyword    location: Which data center to create a node in. If empty,
-                              undefined behavior will be selected. (optional)
-        :type       location: :class:`NodeLocation`
-
-        :keyword   group_name:  Which group this node belongs to. If empty,
-                                 it will be created into 'libcloud' group. If
-                                 it does not found any group in the target
-                                 location (random location if you have not set
-                                 the parameter), then it will create a new
-                                 group with this name.
-        :type     group_name:  c{str}
-
-        :return:               The newly created node.
-        :rtype:                :class:`Node`
-        """
-        # Define the location
-        # To be clear:
-        #     'xml_loc' is the xml element we navigate into (we need links)
-        #     'loc' is the :class:`NodeLocation` entity
-        xml_loc, loc = self._define_create_node_location(**kwargs)
-
-        # Define the Group
-        group = self._define_create_node_group(xml_loc, loc, **kwargs)
-
-        # Register the Node
-        vm = self._define_create_node_node(group, **kwargs)
-
-        # Execute the 'create' in hypervisor action
-        self._deploy_remote(vm)
-
-        # Retrieve it again, to get some schedule-time defined values
-        edit_vm = get_href(vm, 'edit')
-        headers = {'Accept': self.NODE_MIME_TYPE}
-        vm = self.connection.request(edit_vm, headers=headers).object
-        return self._to_node(vm, self)
-
-    def destroy_node(self, node):
-        """
-        Destroy a node
-
-        Depending on the provider, this may destroy all data associated with
-        the node, including backups.
-
-        :param node: The node to be destroyed
-        :type node: :class:`Node`
-
-        :return: True if the destroy was successful, otherwise False
-        :rtype: ``bool``
-        """
-
-        # Refresh node state
-        headers = {'Accept': self.NODE_MIME_TYPE}
-        e_vm = self.connection.request(node.extra['uri_id'],
-                                       headers=headers).object
-
-        state = e_vm.findtext('state')
-
-        if state in ['ALLOCATED', 'CONFIGURED', 'LOCKED', 'UNKNOWN']:
-            raise LibcloudError('Invalid Node state', self)
-
-        if state != 'NOT_ALLOCATED':
-            # prepare the element that forces the undeploy
-            vm_task = ET.Element('virtualmachinetask')
-            force_undeploy = ET.SubElement(vm_task, 'forceUndeploy')
-            force_undeploy.text = 'True'
-            # Set the URI
-            destroy_uri = node.extra['uri_id'] + '/action/undeploy'
-            # Prepare the headers
-            headers = {'Accept': self.AR_MIME_TYPE,
-                       'Content-type': self.VM_TASK_MIME_TYPE}
-            res = self.connection.async_request(action=destroy_uri,
-                                                method='POST',
-                                                data=tostring(vm_task),
-                                                headers=headers)
-
-        if state == 'NOT_ALLOCATED' or res.async_success():
-            self.connection.request(action=node.extra['uri_id'],
-                                    method='DELETE')
-            return True
-        else:
-            return False
-
-    def ex_run_node(self, node):
-        """
-        Runs a node
-
-        Here there is a bit difference between Abiquo states and libcloud
-        states, so this method is created to have better compatibility. In
-        libcloud, if the node is not running, then it does not exist (avoiding
-        UNKNOWN and temporal states). In Abiquo, you can define a node, and
-        then deploy it.
-
-        If the node is in :class:`NodeState.TERMINATED` libcloud's state and in
-        'NOT_DEPLOYED' Abiquo state, there is a way to run and recover it
-        for libcloud using this method. There is no way to reach this state
-        if you are using only libcloud, but you may have used another Abiquo
-        client and now you want to recover your node to be used by libcloud.
-
-        :param node: The node to run
-        :type node: :class:`Node`
-
-        :return: The node itself, but with the new state
-        :rtype: :class:`Node`
-        """
-        # Refresh node state
-        e_vm = self.connection.request(node.extra['uri_id']).object
-        state = e_vm.findtext('state')
-
-        if state != 'NOT_ALLOCATED':
-            raise LibcloudError('Invalid Node state', self)
-
-        # --------------------------------------------------------
-        #     Deploy the Node
-        # --------------------------------------------------------
-        self._deploy_remote(e_vm)
-
-        # --------------------------------------------------------
-        #     Retrieve it again, to get some schedule-defined
-        #     values.
-        # --------------------------------------------------------
-        edit_vm = get_href(e_vm, 'edit')
-        headers = {'Accept': self.NODE_MIME_TYPE}
-        e_vm = self.connection.request(edit_vm, headers=headers).object
-        return self._to_node(e_vm, self)
-
-    def ex_populate_cache(self):
-        """
-        Populate the cache.
-
-        For each connection, it is good to store some objects that will be
-        useful for further requests, such as the 'user' and the 'enterprise'
-        objects.
-
-        Executes the 'login' resource after setting the connection parameters
-        and, if the execution is successful, it sets the 'user' object into
-        cache. After that, it also requests for the 'enterprise' and
-        'locations' data.
-
-        List of locations should remain the same for a single libcloud
-        connection. However, this method is public and you are able to
-        refresh the list of locations any time.
-        """
-
-        user_headers = {'Accept': self.USER_MIME_TYPE}
-        user = self.connection.request('/login', headers=user_headers).object
-        self.connection.cache['user'] = user
-        e_ent = get_href(self.connection.cache['user'],
-                         'enterprise')
-        ent_headers = {'Accept': self.ENT_MIME_TYPE}
-        ent = self.connection.request(e_ent, headers=ent_headers).object
-        self.connection.cache['enterprise'] = ent
-
-        vdcs_headers = {'Accept': self.VDCS_MIME_TYPE}
-        uri_vdcs = '/cloud/virtualdatacenters'
-        e_vdcs = self.connection.request(uri_vdcs, headers=vdcs_headers).object
-
-        params = {"idEnterprise": self._get_enterprise_id()}
-
-        dcs_headers = {'Accept': self.DCS_MIME_TYPE}
-        e_dcs = self.connection.request('/admin/datacenters',
-                                        headers=dcs_headers,
-                                        params=params).object
-        dc_dict = {}
-        for dc in e_dcs.findall('datacenter'):
-            key = get_href(dc, 'self')
-            dc_dict[key] = dc
-
-        # Populate locations name cache
-        self.connection.cache['locations'] = {}
-        for e_vdc in e_vdcs.findall('virtualDatacenter'):
-            loc = get_href(e_vdc, 'location')
-            if loc is not None:
-                self.connection.cache['locations'][loc] = get_href(e_vdc,
-                                                                   'edit')
-
-    def ex_create_group(self, name, location=None):
-        """
-        Create an empty group.
-
-        You can specify the location as well.
-
-        :param     group:     name of the group (required)
-        :type      group:     ``str``
-
-        :param     location: location were to create the group
-        :type      location: :class:`NodeLocation`
-
-        :returns:            the created group
-        :rtype:              :class:`NodeGroup`
-        """
-        # prepare the element
-        vapp = ET.Element('virtualAppliance')
-        vapp_name = ET.SubElement(vapp, 'name')
-        vapp_name.text = name
-
-        if location is None:
-            location = self.list_locations()[0]
-        elif location not in self.list_locations():
-            raise LibcloudError('Location does not exist')
-
-        link_vdc = self.connection.cache['locations'][location]
-        hdr_vdc = {'Accept': self.VDC_MIME_TYPE}
-        e_vdc = self.connection.request(link_vdc, headers=hdr_vdc).object
-
-        creation_link = get_href(e_vdc, 'virtualappliances')
-        headers = {'Accept': self.VAPP_MIME_TYPE,
-                   'Content-type': self.VAPP_MIME_TYPE}
-        vapp = self.connection.request(creation_link, data=tostring(vapp),
-                                       headers=headers, method='POST').object
-
-        uri_vapp = get_href(vapp, 'edit')
-
-        return NodeGroup(self, vapp.findtext('name'),
-                         uri=uri_vapp)
-
-    def ex_destroy_group(self, group):
-        """
-        Destroy a group.
-
-        Be careful! Destroying a group means destroying all the :class:`Node`
-        instances there and the group itself!
-
-        If there is currently any action over any :class:`Node` of the
-        :class:`NodeGroup`, then the method will raise an exception.
-
-        :param     name: The group (required)
-        :type      name: :class:`NodeGroup`
-
-        :return:         If the group was destroyed successfully
-        :rtype:          ``bool``
-        """
-        # Refresh group state
-        e_group = self.connection.request(group.uri).object
-        state = e_group.findtext('state')
-
-        if state not in ['NOT_DEPLOYED', 'DEPLOYED']:
-            error = 'Can not destroy group because of current state'
-            raise LibcloudError(error, self)
-
-        if state == 'DEPLOYED':
-            # prepare the element that forces the undeploy
-            vm_task = ET.Element('virtualmachinetask')
-            force_undeploy = ET.SubElement(vm_task, 'forceUndeploy')
-            force_undeploy.text = 'True'
-
-            # Set the URI
-            undeploy_uri = group.uri + '/action/undeploy'
-
-            # Prepare the headers
-            headers = {'Accept': self.AR_MIME_TYPE,
-                       'Content-type': self.VM_TASK_MIME_TYPE}
-            res = self.connection.async_request(action=undeploy_uri,
-                                                method='POST',
-                                                data=tostring(vm_task),
-                                                headers=headers)
-
-        if state == 'NOT_DEPLOYED' or res.async_success():
-            # The node is no longer deployed. Unregister it.
-            self.connection.request(action=group.uri,
-                                    method='DELETE')
-            return True
-        else:
-            return False
-
-    def ex_list_groups(self, location=None):
-        """
-        List all groups.
-
-        :param location: filter the groups by location (optional)
-        :type  location: a :class:`NodeLocation` instance.
-
-        :return:         the list of :class:`NodeGroup`
-        """
-        groups = []
-        for vdc in self._get_locations(location):
-            link_vdc = self.connection.cache['locations'][vdc]
-            hdr_vdc = {'Accept': self.VDC_MIME_TYPE}
-            e_vdc = self.connection.request(link_vdc, headers=hdr_vdc).object
-            apps_link = get_href(e_vdc, 'virtualappliances')
-            hdr_vapps = {'Accept': self.VAPPS_MIME_TYPE}
-            vapps = self.connection.request(apps_link,
-                                            headers=hdr_vapps).object
-            for vapp in vapps.findall('virtualAppliance'):
-                nodes = []
-                vms_link = get_href(vapp, 'virtualmachines')
-                headers = {'Accept': self.NODES_MIME_TYPE}
-                vms = self.connection.request(vms_link, headers=headers).object
-                for vm in vms.findall('virtualMachine'):
-                    nodes.append(self._to_node(vm, self))
-                group = NodeGroup(self, vapp.findtext('name'),
-                                  nodes, get_href(vapp, 'edit'))
-                groups.append(group)
-
-        return groups
-
-    def list_images(self, location=None):
-        """
-        List images on Abiquo Repositories
-
-        :keyword location: The location to list images for.
-        :type    location: :class:`NodeLocation`
-
-        :return:           list of node image objects
-        :rtype:            ``list`` of :class:`NodeImage`
-        """
-        enterprise_id = self._get_enterprise_id()
-        uri = '/admin/enterprises/%s/datacenterrepositories/' % (enterprise_id)
-        repos_hdr = {'Accept': self.DCRS_MIME_TYPE}
-        repos = self.connection.request(uri, headers=repos_hdr).object
-
-        images = []
-        for repo in repos.findall('datacenterRepository'):
-            # filter by location. Skips when the name of the location
-            # is different from the 'datacenterRepository' element
-            for vdc in self._get_locations(location):
-                # Check if the virtual datacenter belongs to this repo
-                link_vdc = self.connection.cache['locations'][vdc]
-                hdr_vdc = {'Accept': self.VDC_MIME_TYPE}
-                e_vdc = self.connection.request(link_vdc,
-                                                headers=hdr_vdc).object
-                dc_link_vdc = get_href(e_vdc, 'location')
-                dc_link_repo = get_href(repo, 'datacenter')
-
-                if dc_link_vdc.split("/")[-1] == dc_link_repo.split("/")[-1]:
-                    # Filter the template in case we don't have it yet
-                    url_templates = get_href(repo, 'virtualmachinetemplates')
-                    hypervisor_type = e_vdc.findtext('hypervisorType')
-                    params = {'hypervisorTypeName': hypervisor_type}
-                    headers = {'Accept': self.VMTPLS_MIME_TYPE}
-                    templates = self.connection.request(url_templates, params,
-                                                        headers=headers).object
-                    for templ in templates.findall('virtualMachineTemplate'):
-                        # Avoid duplicated templates
-                        id_template = templ.findtext('id')
-                        ids = [image.id for image in images]
-                        if id_template not in ids:
-                            images.append(self._to_nodeimage(templ, self,
-                                                             get_href(repo,
-                                                                      'edit')))
-
-        return images
-
-    def list_locations(self):
-        """
-        Return list of locations where the user has access to.
-
-        :return: the list of :class:`NodeLocation` available for the current
-                 user
-        :rtype:  ``list`` of :class:`NodeLocation`
-        """
-        return list(self.connection.cache['locations'].keys())
-
-    def list_nodes(self, location=None):
-        """
-        List all nodes.
-
-        :param location: Filter the groups by location (optional)
-        :type  location: a :class:`NodeLocation` instance.
-
-        :return:  List of node objects
-        :rtype: ``list`` of :class:`Node`
-        """
-        nodes = []
-
-        for group in self.ex_list_groups(location):
-            nodes.extend(group.nodes)
-
-        return nodes
-
-    def list_sizes(self, location=None):
-        """
-        List sizes on a provider.
-
-        Abiquo does not work with sizes. However, this method
-        returns a list of predefined ones (copied from :class:`DummyNodeDriver`
-        but without price neither bandwidth) to help the users to create their
-        own.
-
-        If you call the method :class:`AbiquoNodeDriver.create_node` with the
-        size informed, it will just override the 'ram' value of the 'image'
-        template. So it is no too much usefull work with sizes...
-
-        :return: The list of sizes
-        :rtype:  ``list`` of :class:`NodeSizes`
-        """
-        return [
-            NodeSize(id=1,
-                     name='Small',
-                     ram=128,
-                     disk=4,
-                     bandwidth=None,
-                     price=None,
-                     driver=self),
-            NodeSize(id=2,
-                     name='Medium',
-                     ram=512,
-                     disk=16,
-                     bandwidth=None,
-                     price=None,
-                     driver=self),
-            NodeSize(id=3,
-                     name='Big',
-                     ram=4096,
-                     disk=32,
-                     bandwidth=None,
-                     price=None,
-                     driver=self),
-            NodeSize(id=4,
-                     name="XXL Big",
-                     ram=4096 * 2,
-                     disk=32 * 4,
-                     bandwidth=None,
-                     price=None,
-                     driver=self)
-        ]
-
-    def reboot_node(self, node):
-        """
-        Reboot a node.
-
-        :param node: The node to be rebooted
-        :type node: :class:`Node`
-
-        :return: True if the reboot was successful, otherwise False
-        :rtype: ``bool``
-        """
-        reboot_uri = node.extra['uri_id'] + '/action/reset'
-        reboot_hdr = {'Accept': self.AR_MIME_TYPE}
-        res = self.connection.async_request(action=reboot_uri,
-                                            method='POST', headers=reboot_hdr)
-        return res.async_success()
-
-    # -------------------------
-    # Extenstion methods
-    # -------------------------
-
-    def _ex_connection_class_kwargs(self):
-        """
-        Set the endpoint as an extra :class:`AbiquoConnection` argument.
-
-        According to Connection code, the "url" argument should be
-        parsed properly to connection.
-
-        :return: ``dict`` of :class:`AbiquoConnection` input arguments
-        """
-
-        return {'url': self.endpoint}
-
-    def _deploy_remote(self, e_vm):
-        """
-        Asynchronous call to create the node.
-        """
-        # --------------------------------------------------------
-        #     Deploy the Node
-        # --------------------------------------------------------
-        # prepare the element that forces the deploy
-        vm_task = ET.Element('virtualmachinetask')
-        force_deploy = ET.SubElement(vm_task, 'forceEnterpriseSoftLimits')
-        force_deploy.text = 'True'
-
-        # Prepare the headers
-        headers = {'Accept': self.AR_MIME_TYPE,
-                   'Content-type': self.VM_TASK_MIME_TYPE}
-        link_deploy = get_href(e_vm, 'deploy')
-        res = self.connection.async_request(action=link_deploy, method='POST',
-                                            data=tostring(vm_task),
-                                            headers=headers)
-        if not res.async_success():
-            raise LibcloudError('Could not run the node', self)
-
-    def _to_location(self, vdc, dc, driver):
-        """
-        Generates the :class:`NodeLocation` class.
-        """
-        identifier = vdc.findtext('id')
-        name = vdc.findtext('name')
-        country = dc.findtext('name')
-        return NodeLocation(identifier, name, country, driver)
-
-    def _to_node(self, vm, driver):
-        """
-        Generates the :class:`Node` class.
-        """
-        identifier = vm.findtext('id')
-        name = vm.findtext('label')
-        state = AbiquoResponse.NODE_STATE_MAP[vm.findtext('state')]
-
-        link_image = get_href(vm, 'virtualmachinetemplate')
-        link_hdr = {'Accept': self.VMTPL_MIME_TYPE}
-        image_element = self.connection.request(link_image,
-                                                headers=link_hdr).object
-        repo_link = get_href(image_element, 'datacenterrepository')
-        image = self._to_nodeimage(image_element, self, repo_link)
-
-        # Fill the 'ips' data
-        private_ips = []
-        public_ips = []
-        nics_hdr = {'Accept': self.NICS_MIME_TYPE}
-        nics_element = self.connection.request(get_href(vm, 'nics'),
-                                               headers=nics_hdr).object
-        for nic in nics_element.findall('nic'):
-            ip = nic.findtext('ip')
-            for link in nic.findall('link'):
-                rel = link.attrib['rel']
-                if rel == 'privatenetwork':
-                    private_ips.append(ip)
-                elif rel in ['publicnetwork', 'externalnetwork',
-                             'unmanagednetwork']:
-                    public_ips.append(ip)
-
-        extra = {'uri_id': get_href(vm, 'edit')}
-
-        if vm.find('vdrpIp') is not None:
-            extra['vdrp_ip'] = vm.findtext('vdrpIP')
-            extra['vdrp_port'] = vm.findtext('vdrpPort')
-
-        return Node(identifier, name, state, public_ips, private_ips,
-                    driver, image=image, extra=extra)
-
-    def _to_nodeimage(self, template, driver, repo):
-        """
-        Generates the :class:`NodeImage` class.
-        """
-        identifier = template.findtext('id')
-        name = template.findtext('name')
-        url = get_href(template, 'edit')
-        hdreqd = template.findtext('hdRequired')
-        extra = {'repo': repo, 'url': url, 'hdrequired': hdreqd}
-        return NodeImage(identifier, name, driver, extra)
-
-    def _get_locations(self, location=None):
-        """
-        Returns the locations as a generator.
-        """
-        if location is not None:
-            yield location
-        else:
-            for loc in self.list_locations():
-                yield loc
-
-    def _get_enterprise_id(self):
-        """
-        Returns the identifier of the logged user's enterprise.
-        """
-        return self.connection.cache['enterprise'].findtext('id')
-
-    def _define_create_node_location(self, **kwargs):
-        """
-        Search for a location where to create the node.
-
-        Based on 'create_node' **kwargs argument, decide in which
-        location will be created.
-        """
-        # First, get image location
-        if 'image' not in kwargs:
-            error = "'image' parameter is mandatory"
-            raise LibcloudError(error, self)
-
-        image = kwargs['image']
-
-        # Get the location argument
-        location = None
-        if 'location' in kwargs:
-            location = kwargs['location']
-            if location not in self.list_locations():
-                raise LibcloudError('Location does not exist')
-
-        # Check if the image is compatible with any of the locations or
-        # the input location
-        loc = None
-        target_loc = None
-        for candidate_loc in self._get_locations(location):
-            link_vdc = self.connection.cache['locations'][candidate_loc]
-            hdr_vdc = {'Accept': self.VDC_MIME_TYPE}
-            e_vdc = self.connection.request(link_vdc, headers=hdr_vdc).object
-            for img in self.list_images(candidate_loc):
-                if img.id == image.id:
-                    loc = e_vdc
-                    target_loc = candidate_loc
-                    break
-
-        if loc is None:
-            error = 'The image can not be used in any location'
-            raise LibcloudError(error, self)
-
-        return loc, target_loc
-
-    def _define_create_node_group(self, xml_loc, loc, **kwargs):
-        """
-        Search for a group where to create the node.
-
-        If we can not find any group, create it into argument 'location'
-        """
-        if 'group_name' not in kwargs:
-            group_name = NodeGroup.DEFAULT_GROUP_NAME
-        else:
-            group_name = kwargs['group_name']
-
-        # We search if the group is already defined into the location
-        groups_link = get_href(xml_loc, 'virtualappliances')
-        groups_hdr = {'Accept': self.VAPPS_MIME_TYPE}
-        vapps_element = self.connection.request(groups_link,
-                                                headers=groups_hdr).object
-        target_group = None
-        for vapp in vapps_element.findall('virtualAppliance'):
-            if vapp.findtext('name') == group_name:
-                uri_vapp = get_href(vapp, 'edit')
-                return NodeGroup(self, vapp.findtext('name'), uri=uri_vapp)
-
-        # target group not found: create it. Since it is an extension of
-        # the basic 'libcloud' functionality, we try to be as flexible as
-        # possible.
-        if target_group is None:
-            return self.ex_create_group(group_name, loc)
-
-    def _define_create_node_node(self, group, **kwargs):
-        """
-        Defines the node before to create.
-
-        In Abiquo, you first need to 'register' or 'define' the node in
-        the API before to create it into the target hypervisor.
-        """
-        vm = ET.Element('virtualMachine')
-        if 'name' in kwargs:
-            vmname = ET.SubElement(vm, 'label')
-            vmname.text = kwargs['name']
-        attrib = {'type': self.VMTPL_MIME_TYPE,
-                  'rel': 'virtualmachinetemplate',
-                  'href': kwargs['image'].extra['url']}
-        ET.SubElement(vm, 'link', attrib=attrib)
-        headers = {'Accept': self.NODE_MIME_TYPE,
-                   'Content-type': self.NODE_MIME_TYPE}
-
-        if 'size' in kwargs:
-            # Override the 'NodeSize' data
-            ram = ET.SubElement(vm, 'ram')
-            ram.text = str(kwargs['size'].ram)
-            hd = ET.SubElement(vm, 'hdInBytes')
-            hd.text = str(int(kwargs['size'].disk) * self.GIGABYTE)
-
-        # Create the virtual machine
-        nodes_link = group.uri + '/virtualmachines'
-        vm = self.connection.request(nodes_link, data=tostring(vm),
-                                     headers=headers, method='POST').object
-        edit_vm = get_href(vm, 'edit')
-        headers = {'Accept': self.NODE_MIME_TYPE}
-
-        return self.connection.request(edit_vm, headers=headers).object
-
-
-class NodeGroup(object):
-    """
-    Group of virtual machines that can be managed together
-
-    All :class:`Node`s in Abiquo must be defined inside a Virtual Appliance.
-    We offer a way to handle virtual appliances (called NodeGroup to
-    maintain some kind of name conventions here) inside the
-    :class:`AbiquoNodeDriver` without breaking compatibility of the rest of
-    libcloud API.
-
-    If the user does not want to handle groups, all the virtual machines
-    will be created inside a group named 'libcloud'
-    """
-    DEFAULT_GROUP_NAME = 'libcloud'
-
-    def __init__(self, driver, name=DEFAULT_GROUP_NAME, nodes=[], uri=''):
-        """
-        Initialize a new group object.
-        """
-        self.driver = driver
-        self.name = name
-        self.nodes = nodes
-        self.uri = uri
-
-    def __repr__(self):
-        return (('<NodeGroup: name=%s, nodes=[%s] >')
-                % (self.name, ",".join(map(str, self.nodes))))
-
-    def destroy(self):
-        """
-        Destroys the group delegating the execution to
-        :class:`AbiquoNodeDriver`.
-        """
-        return self.driver.ex_destroy_group(self)

http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/auroracompute.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/auroracompute.py b/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/auroracompute.py
deleted file mode 100644
index 6be67ed..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/auroracompute.py
+++ /dev/null
@@ -1,57 +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.compute.providers import Provider
-from libcloud.compute.drivers.cloudstack import CloudStackNodeDriver
-
-__all__ = [
-    'AuroraComputeRegion',
-    'AuroraComputeNodeDriver'
-]
-
-
-class AuroraComputeRegion(object):
-    AMS = 'Amsterdam'
-    RTD = 'Rotterdam'
-    MIA = 'Miami'
-    LAX = 'Los Angeles'
-    TYO = 'Tokyo'
-
-
-REGION_ENDPOINT_MAP = {
-    AuroraComputeRegion.AMS: '/ams',
-    AuroraComputeRegion.RTD: '/rtd',
-    AuroraComputeRegion.MIA: '/mia',
-    AuroraComputeRegion.LAX: '/lax',
-    AuroraComputeRegion.TYO: '/tyo'
-}
-
-
-class AuroraComputeNodeDriver(CloudStackNodeDriver):
-    type = Provider.AURORACOMPUTE
-    name = 'PCextreme AuroraCompute'
-    website = 'https://www.pcextreme.com/aurora/compute'
-
-    def __init__(self, key, secret, path=None, host=None, url=None,
-                 region=None):
-        if host is None:
-            host = 'api.auroracompute.eu'
-
-        if path is None:
-            path = REGION_ENDPOINT_MAP.get(region, '/ams')
-
-        super(AuroraComputeNodeDriver, self).__init__(key=key, secret=secret,
-                                                      host=host, path=path,
-                                                      secure=True)


Mime
View raw message