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:21 UTC
[34/56] [abbrv] libcloud git commit: Removed sdist
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/azure_arm.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/azure_arm.py b/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/azure_arm.py
deleted file mode 100644
index c7d0441..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/azure_arm.py
+++ /dev/null
@@ -1,1281 +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.
-
-"""
-Driver for Microsoft Azure Resource Manager (ARM) Virtual Machines provider.
-
-http://azure.microsoft.com/en-us/services/virtual-machines/
-"""
-
-import base64
-import binascii
-import os
-import time
-
-from libcloud.common.azure_arm import AzureResourceManagementConnection
-from libcloud.compute.providers import Provider
-from libcloud.compute.base import Node, NodeDriver, NodeLocation, NodeSize
-from libcloud.compute.base import NodeImage, NodeAuthSSHKey
-from libcloud.compute.base import NodeAuthPassword
-from libcloud.compute.types import NodeState
-from libcloud.common.types import LibcloudError
-from libcloud.storage.types import ObjectDoesNotExistError
-from libcloud.common.exceptions import BaseHTTPError
-from libcloud.storage.drivers.azure_blobs import AzureBlobsStorageDriver
-from libcloud.utils.py3 import basestring
-
-
-class AzureImage(NodeImage):
- """Represents a Marketplace node image that an Azure VM can boot from."""
-
- def __init__(self, version, sku, offer, publisher, location, driver):
- self.publisher = publisher
- self.offer = offer
- self.sku = sku
- self.version = version
- self.location = location
- urn = "%s:%s:%s:%s" % (self.publisher, self.offer,
- self.sku, self.version)
- name = "%s %s %s %s" % (self.publisher, self.offer,
- self.sku, self.version)
- super(AzureImage, self).__init__(urn, name, driver)
-
- def __repr__(self):
- return (('<AzureImage: id=%s, name=%s, location=%s>')
- % (self.id, self.name, self.location))
-
-
-class AzureVhdImage(NodeImage):
- """Represents a VHD node image that an Azure VM can boot from."""
-
- def __init__(self, storage_account, blob_container, name, driver):
- urn = "https://%s.blob.core.windows.net/%s/%s" % (storage_account,
- blob_container,
- name)
- super(AzureVhdImage, self).__init__(urn, name, driver)
-
- def __repr__(self):
- return (('<AzureVhdImage: id=%s, name=%s, location=%s>')
- % (self.id, self.name, self.location))
-
-
-class AzureNetwork(object):
- """Represent an Azure virtual network."""
-
- def __init__(self, id, name, location, extra):
- self.id = id
- self.name = name
- self.location = location
- self.extra = extra
-
- def __repr__(self):
- return (('<AzureNetwork: id=%s, name=%s, location=%s ...>')
- % (self.id, self.name, self.location))
-
-
-class AzureSubnet(object):
- """Represents a subnet of an Azure virtual network."""
-
- def __init__(self, id, name, extra):
- self.id = id
- self.name = name
- self.extra = extra
-
- def __repr__(self):
- return (('<AzureSubnet: id=%s, name=%s ...>')
- % (self.id, self.name))
-
-
-class AzureNic(object):
- """Represents an Azure virtual network interface controller (NIC)."""
-
- def __init__(self, id, name, location, extra):
- self.id = id
- self.name = name
- self.location = location
- self.extra = extra
-
- def __repr__(self):
- return (('<AzureNic: id=%s, name=%s ...>')
- % (self.id, self.name))
-
-
-class AzureIPAddress(object):
- """Represents an Azure public IP address resource."""
-
- def __init__(self, id, name, extra):
- self.id = id
- self.name = name
- self.extra = extra
-
- def __repr__(self):
- return (('<AzureIPAddress: id=%s, name=%s ...>')
- % (self.id, self.name))
-
-
-class AzureNodeDriver(NodeDriver):
- """Compute node driver for Azure Resource Manager."""
-
- connectionCls = AzureResourceManagementConnection
- name = 'Azure Virtual machines'
- website = 'http://azure.microsoft.com/en-us/services/virtual-machines/'
- type = Provider.AZURE_ARM
- features = {'create_node': ['ssh_key', 'password']}
-
- # The API doesn't provide state or country information, so fill it in.
- # Information from https://azure.microsoft.com/en-us/regions/
- _location_to_country = {
- "centralus": "Iowa, USA",
- "eastus": "Virginia, USA",
- "eastus2": "Virginia, USA",
- "usgoviowa": "Iowa, USA",
- "usgovvirginia": "Virginia, USA",
- "northcentralus": "Illinois, USA",
- "southcentralus": "Texas, USA",
- "westus": "California, USA",
- "northeurope": "Ireland",
- "westeurope": "Netherlands",
- "eastasia": "Hong Kong",
- "southeastasia": "Singapore",
- "japaneast": "Tokyo, Japan",
- "japanwest": "Osaka, Japan",
- "brazilsouth": "Sao Paulo State, Brazil",
- "australiaeast": "New South Wales, Australia",
- "australiasoutheast": "Victoria, Australia"
- }
-
- def __init__(self, tenant_id, subscription_id, key, secret,
- secure=True, host=None, port=None,
- api_version=None, region=None, **kwargs):
- self.tenant_id = tenant_id
- self.subscription_id = subscription_id
- super(AzureNodeDriver, self).__init__(key=key, secret=secret,
- secure=secure,
- host=host, port=port,
- api_version=api_version,
- region=region, **kwargs)
- if self.region is not None:
- loc_id = self.region.lower().replace(" ", "")
- country = self._location_to_country.get(loc_id)
- self.default_location = NodeLocation(loc_id,
- self.region,
- country,
- self)
- else:
- self.default_location = None
-
- def list_locations(self):
- """
- List data centers available with the current subscription.
-
- :return: list of node location objects
- :rtype: ``list`` of :class:`.NodeLocation`
- """
-
- action = "/subscriptions/%s/providers/Microsoft.Compute" % (
- self.subscription_id)
- r = self.connection.request(action,
- params={"api-version": "2015-01-01"})
-
- for rt in r.object["resourceTypes"]:
- if rt["resourceType"] == "virtualMachines":
- return [self._to_location(l) for l in rt["locations"]]
-
- return []
-
- def list_sizes(self, location=None):
- """
- List available VM sizes.
-
- :param location: The location at which to list sizes
- (if None, use default location specified as 'region' in __init__)
- :type location: :class:`.NodeLocation`
-
- :return: list of node size objects
- :rtype: ``list`` of :class:`.NodeSize`
- """
-
- if location is None:
- if self.default_location:
- location = self.default_location
- else:
- raise ValueError("location is required.")
- action = \
- "/subscriptions/%s/providers/Microsoft" \
- ".Compute/locations/%s/vmSizes" \
- % (self.subscription_id, location.id)
- r = self.connection.request(action,
- params={"api-version": "2015-06-15"})
- return [self._to_node_size(d) for d in r.object["value"]]
-
- def list_images(self, location=None, ex_publisher=None, ex_offer=None,
- ex_sku=None, ex_version=None):
- """
- List available VM images to boot from.
-
- :param location: The location at which to list images
- (if None, use default location specified as 'region' in __init__)
- :type location: :class:`.NodeLocation`
-
- :param ex_publisher: Filter by publisher, or None to list
- all publishers.
- :type ex_publisher: ``str``
-
- :param ex_offer: Filter by offer, or None to list all offers.
- :type ex_offer: ``str``
-
- :param ex_sku: Filter by sku, or None to list all skus.
- :type ex_sku: ``str``
-
- :param ex_version: Filter by version, or None to list all versions.
- :type ex_version: ``str``
-
- :return: list of node image objects.
- :rtype: ``list`` of :class:`.AzureImage`
- """
-
- images = []
-
- if location is None:
- locations = [self.default_location]
- else:
- locations = [location]
-
- for loc in locations:
- if not ex_publisher:
- publishers = self.ex_list_publishers(loc)
- else:
- publishers = [(
- "/subscriptions/%s/providers/Microsoft"
- ".Compute/locations/%s/publishers/%s" %
- (self.subscription_id, loc.id, ex_publisher),
- ex_publisher)]
-
- for pub in publishers:
- if not ex_offer:
- offers = self.ex_list_offers(pub[0])
- else:
- offers = [("%s/artifacttypes/vmimage/offers/%s" % (
- pub[0], ex_offer), ex_offer)]
-
- for off in offers:
- if not ex_sku:
- skus = self.ex_list_skus(off[0])
- else:
- skus = [("%s/skus/%s" % (off[0], ex_sku), ex_sku)]
-
- for sku in skus:
- if not ex_version:
- versions = self.ex_list_image_versions(sku[0])
- else:
- versions = [("%s/versions/%s" % (
- sku[0], ex_version), ex_version)]
-
- for v in versions:
- images.append(AzureImage(v[1], sku[1],
- off[1], pub[1],
- loc.id,
- self.connection.driver))
- return images
-
- def get_image(self, image_id, location=None):
- """Returns a single node image from a provider.
-
- :param image_id: Either an image urn in the form
- `Publisher:Offer:Sku:Version` or a Azure blob store URI in the form
- `http://storageaccount.blob.core.windows.net/container/image.vhd`
- pointing to a VHD file.
- :type image_id: ``str``
-
- :param location: The location at which to search for the image
- (if None, use default location specified as 'region' in __init__)
- :type location: :class:`.NodeLocation`
-
- :rtype :class:`.AzureImage`: or :class:`.AzureVhdImage`:
- :return: AzureImage or AzureVhdImage instance on success.
-
- """
-
- if image_id.startswith("http"):
- (storageAccount, blobContainer, blob) = _split_blob_uri(image_id)
- return AzureVhdImage(storageAccount, blobContainer, blob, self)
- else:
- (ex_publisher, ex_offer, ex_sku, ex_version) = image_id.split(":")
- i = self.list_images(location, ex_publisher,
- ex_offer, ex_sku, ex_version)
- return i[0] if i else None
-
- def list_nodes(self, ex_resource_group=None, ex_fetch_nic=True):
- """
- List all nodes.
-
- :param ex_resource_group: List nodes in a specific resource group.
- :type ex_urn: ``str``
-
- :param ex_fetch_nic: Fetch NIC resources in order to get
- IP address information for nodes (requires extra API calls).
- :type ex_urn: ``bool``
-
- :return: list of node objects
- :rtype: ``list`` of :class:`.Node`
- """
-
- if ex_resource_group:
- action = "/subscriptions/%s/resourceGroups/%s/" \
- "providers/Microsoft.Compute/virtualMachines" \
- % (self.subscription_id, ex_resource_group)
- else:
- action = "/subscriptions/%s/providers/Microsoft.Compute/" \
- "virtualMachines" \
- % (self.subscription_id)
- r = self.connection.request(action,
- params={"api-version": "2015-06-15"})
- return [self._to_node(n, fetch_nic=ex_fetch_nic)
- for n in r.object["value"]]
-
- def create_node(self,
- name,
- size,
- image,
- auth,
- ex_resource_group,
- ex_storage_account,
- ex_blob_container="vhds",
- location=None,
- ex_user_name="azureuser",
- ex_network=None,
- ex_subnet=None,
- ex_nic=None,
- ex_tags={},
- ex_customdata=""):
- """Create a new node instance. This instance will be started
- automatically.
-
- This driver supports the ``ssh_key`` feature flag for ``created_node``
- so you can upload a public key into the new instance::
-
- >>> from libcloud.compute.drivers.azure_arm import AzureNodeDriver
- >>> driver = AzureNodeDriver(...)
- >>> auth = NodeAuthSSHKey('pubkey data here')
- >>> node = driver.create_node("test_node", auth=auth)
-
- This driver also supports the ``password`` feature flag for
- ``create_node``
- so you can set a password::
-
- >>> driver = AzureNodeDriver(...)
- >>> auth = NodeAuthPassword('mysecretpassword')
- >>> node = driver.create_node("test_node", auth=auth, ...)
-
- If you don't provide the ``auth`` argument libcloud will assign
- a password::
-
- >>> driver = AzureNodeDriver(...)
- >>> node = driver.create_node("test_node", ...)
- >>> password = node.extra["properties"] \
- ["osProfile"]["adminPassword"]
-
- :param name: String with a name for this new node (required)
- :type name: ``str``
-
- :param size: The size of resources allocated to this node.
- (required)
- :type size: :class:`.NodeSize`
-
- :param image: OS Image to boot on node. (required)
- :type image: :class:`.AzureImage`
-
- :param location: Which data center to create a node in.
- (if None, use default location specified as 'region' in __init__)
- :type location: :class:`.NodeLocation`
-
- :param auth: Initial authentication information for the node
- (optional)
- :type auth: :class:`.NodeAuthSSHKey` or :class:`NodeAuthPassword`
-
- :param ex_resource_group: The resource group in which to create the
- node
- :type ex_resource_group: ``str``
-
- :param ex_storage_account: The storage account id in which to store
- the node's disk image.
- Note: when booting from a user image (AzureVhdImage)
- the source image and the node image must use the same storage account.
- :type ex_storage_account: ``str``
-
- :param ex_blob_container: The name of the blob container on the
- storage account in which to store the node's disk image (optional,
- default "vhds")
- :type ex_blob_container: ``str``
-
- :param ex_user_name: User name for the initial admin user
- (optional, default "azureuser")
- :type ex_user_name: ``str``
-
- :param ex_network: The virtual network the node will be attached to.
- Must provide either `ex_network` (to create a default NIC for the
- node on the given network) or `ex_nic` (to supply the NIC explicitly).
- :type ex_network: ``str``
-
- :param ex_subnet: If ex_network is provided, the subnet of the
- virtual network the node will be attached to. Optional, default
- is the "default" subnet.
- :type ex_subnet: ``str``
-
- :param ex_nic: A virtual NIC to attach to this Node, from
- `ex_create_network_interface` or `ex_get_nic`.
- Must provide either `ex_nic` (to supply the NIC explicitly) or
- ex_network (to create a default NIC for the node on the
- given network).
- :type ex_nic: :class:`AzureNic`
-
- :param ex_tags: Optional tags to associate with this node.
- :type ex_tags: ``dict``
-
- :param ex_customdata: Custom data that will
- be placed in the file /var/lib/waagent/CustomData
- https://azure.microsoft.com/en-us/documentation/ \
- articles/virtual-machines-how-to-inject-custom-data/
- :type ex_customdata: ``str``
-
- :return: The newly created node.
- :rtype: :class:`.Node`
-
- """
-
- if location is None:
- location = self.default_location
- if ex_nic is None:
- if ex_network is None:
- raise ValueError("Must provide either ex_network or ex_nic")
- if ex_subnet is None:
- ex_subnet = "default"
-
- subnet_id = "/subscriptions/%s/resourceGroups/%s/providers" \
- "/Microsoft.Network/virtualnetworks/%s/subnets/%s" % \
- (self.subscription_id, ex_resource_group,
- ex_network, ex_subnet)
- subnet = AzureSubnet(subnet_id, ex_subnet, {})
- ex_nic = self.ex_create_network_interface(name + "-nic",
- subnet,
- ex_resource_group,
- location)
-
- auth = self._get_and_check_auth(auth)
-
- target = "/subscriptions/%s/resourceGroups/%s/providers" \
- "/Microsoft.Compute/virtualMachines/%s" % \
- (self.subscription_id, ex_resource_group, name)
-
- n = 0
- while True:
- try:
- instance_vhd = "https://%s.blob.core.windows.net" \
- "/%s/%s-os_%i.vhd" \
- % (ex_storage_account,
- ex_blob_container,
- name,
- n)
- self._ex_delete_old_vhd(ex_resource_group, instance_vhd)
- break
- except LibcloudError:
- n += 1
-
- if isinstance(image, AzureVhdImage):
- storageProfile = {
- "osDisk": {
- "name": "virtualmachine-osDisk",
- "osType": "linux",
- "caching": "ReadWrite",
- "createOption": "FromImage",
- "image": {
- "uri": image.id
- },
- "vhd": {
- "uri": instance_vhd
- }
- }
- }
- elif isinstance(image, AzureImage):
- storageProfile = {
- "imageReference": {
- "publisher": image.publisher,
- "offer": image.offer,
- "sku": image.sku,
- "version": image.version
- },
- "osDisk": {
- "name": "virtualmachine-osDisk",
- "vhd": {
- "uri": instance_vhd
- },
- "caching": "ReadWrite",
- "createOption": "FromImage"
- }
- }
- else:
- raise LibcloudError(
- "Unknown image type %s,"
- "expected one of AzureImage, AzureVhdImage",
- type(image))
-
- data = {
- "id": target,
- "name": name,
- "type": "Microsoft.Compute/virtualMachines",
- "location": location.id,
- "tags": ex_tags,
- "properties": {
- "hardwareProfile": {
- "vmSize": size.id
- },
- "storageProfile": storageProfile,
- "osProfile": {
- "computerName": name
- },
- "networkProfile": {
- "networkInterfaces": [
- {
- "id": ex_nic.id
- }
- ]
- }
- }
- }
-
- if ex_customdata:
- data["properties"]["osProfile"]["customData"] = \
- base64.b64encode(ex_customdata)
-
- data["properties"]["osProfile"]["adminUsername"] = ex_user_name
-
- if isinstance(auth, NodeAuthSSHKey):
- data["properties"]["osProfile"]["adminPassword"] = \
- binascii.hexlify(os.urandom(20))
- data["properties"]["osProfile"]["linuxConfiguration"] = {
- "disablePasswordAuthentication": "true",
- "ssh": {
- "publicKeys": [
- {
- "path": '/home/%s/.ssh/authorized_keys' % (
- ex_user_name),
- "keyData": auth.pubkey
- }
- ]
- }
- }
- elif isinstance(auth, NodeAuthPassword):
- data["properties"]["osProfile"]["linuxConfiguration"] = {
- "disablePasswordAuthentication": "false"
- }
- data["properties"]["osProfile"]["adminPassword"] = auth.password
- else:
- raise ValueError(
- "Must provide NodeAuthSSHKey or NodeAuthPassword in auth")
-
- r = self.connection.request(target,
- params={"api-version": "2015-06-15"},
- data=data,
- method="PUT")
-
- node = self._to_node(r.object)
- node.size = size
- node.image = image
- return node
-
- 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``
- """
-
- target = "%s/restart" % node.id
- try:
- self.connection.request(target,
- params={"api-version": "2015-06-15"},
- method='POST')
- return True
- except BaseHTTPError as h:
- if h.code == 202:
- return True
- else:
- return False
-
- def destroy_node(self, node, ex_destroy_nic=True, ex_destroy_vhd=True):
- """
- Destroy a node.
-
- :param node: The node to be destroyed
- :type node: :class:`.Node`
-
- :param ex_destroy_nic: Destroy the NICs associated with
- this node (default True).
- :type node: ``bool``
-
- :param ex_destroy_vhd: Destroy the OS disk blob associated with
- this node (default True).
- :type node: ``bool``
-
- :return: True if the destroy was successful, False otherwise.
- :rtype: ``bool``
- """
-
- # This returns a 202 (Accepted) which means that the delete happens
- # asynchronously.
- try:
- self.connection.request(node.id,
- params={"api-version": "2015-06-15"},
- method='DELETE')
- except BaseHTTPError as h:
- if h.code == 202:
- pass
- else:
- return False
-
- # Need to poll until the node actually goes away.
- while True:
- try:
- time.sleep(10)
- self.connection.request(
- node.id,
- params={"api-version": "2015-06-15"})
- except BaseHTTPError as h:
- if h.code == 404:
- break
- else:
- return False
-
- # Optionally clean up the network
- # interfaces that were attached to this node.
- interfaces = \
- node.extra["properties"]["networkProfile"]["networkInterfaces"]
- if ex_destroy_nic:
- for nic in interfaces:
- while True:
- try:
- self.connection.request(nic["id"],
- params={
- "api-version":
- "2015-06-15"},
- method='DELETE')
- break
- except BaseHTTPError as h:
- if h.code == 202:
- break
- inuse = h.message.startswith("[NicInUse]")
- if h.code == 400 and inuse:
- time.sleep(10)
- else:
- return False
-
- # Optionally clean up OS disk VHD.
- vhd_uri = \
- node.extra["properties"]["storageProfile"]["osDisk"]["vhd"]["uri"]
- if ex_destroy_vhd:
- while True:
- try:
- resourceGroup = node.id.split("/")[4]
- self._ex_delete_old_vhd(
- resourceGroup,
- vhd_uri)
- break
- except LibcloudError as e:
- if "LeaseIdMissing" in str(e):
- # Unfortunately lease errors
- # (which occur if the vhd blob
- # hasn't yet been released by the VM being destroyed)
- # get raised as plain
- # LibcloudError. Wait a bit and try again.
- time.sleep(10)
- else:
- raise
-
- return True
-
- def ex_list_publishers(self, location=None):
- """
- List node image publishers.
-
- :param location: The location at which to list publishers
- (if None, use default location specified as 'region' in __init__)
- :type location: :class:`.NodeLocation`
-
- :return: A list of tuples in the form
- ("publisher id", "publisher name")
- :rtype: ``list``
- """
-
- if location is None and self.default_location:
- location = self.default_location
- else:
- raise ValueError("location is required.")
-
- action = "/subscriptions/%s/providers/Microsoft.Compute/" \
- "locations/%s/publishers" \
- % (self.subscription_id, location.id)
- r = self.connection.request(action,
- params={"api-version": "2015-06-15"})
- return [(p["id"], p["name"]) for p in r.object]
-
- def ex_list_offers(self, publisher):
- """
- List node image offers from a publisher.
-
- :param publisher: The complete resource path to a publisher
- (as returned by `ex_list_publishers`)
- :type publisher: ``str``
-
- :return: A list of tuples in the form
- ("offer id", "offer name")
- :rtype: ``list``
- """
-
- action = "%s/artifacttypes/vmimage/offers" % (publisher)
- r = self.connection.request(action,
- params={"api-version": "2015-06-15"})
- return [(p["id"], p["name"]) for p in r.object]
-
- def ex_list_skus(self, offer):
- """
- List node image skus in an offer.
-
- :param offer: The complete resource path to an offer (as returned by
- `ex_list_offers`)
- :type publisher: ``str``
-
- :return: A list of tuples in the form
- ("sku id", "sku name")
- :rtype: ``list``
- """
-
- action = "%s/skus" % (offer)
- r = self.connection.request(action,
- params={"api-version": "2015-06-15"})
- return [(sku["id"], sku["name"]) for sku in r.object]
-
- def ex_list_image_versions(self, sku):
- """
- List node image versions in a sku.
-
- :param sku: The complete resource path to a sku (as returned by
- `ex_list_skus`)
- :type publisher: ``str``
-
- :return: A list of tuples in the form
- ("version id", "version name")
- :rtype: ``list``
- """
-
- action = "%s/versions" % (sku)
- r = self.connection.request(action,
- params={"api-version": "2015-06-15"})
- return [(img["id"], img["name"]) for img in r.object]
-
- def ex_list_networks(self):
- """
- List virtual networks.
-
- :return: A list of virtual networks.
- :rtype: ``list`` of :class:`.AzureNetwork`
- """
-
- action = "/subscriptions/%s/providers/" \
- "Microsoft.Network/virtualnetworks" \
- % (self.subscription_id)
- r = self.connection.request(action,
- params={"api-version": "2015-06-15"})
- return [AzureNetwork(net["id"], net["name"], net["location"],
- net["properties"]) for net in r.object["value"]]
-
- def ex_list_subnets(self, network):
- """
- List subnets of a virtual network.
-
- :param network: The virtual network containing the subnets.
- :type network: :class:`.AzureNetwork`
-
- :return: A list of subnets.
- :rtype: ``list`` of :class:`.AzureSubnet`
- """
-
- action = "%s/subnets" % (network.id)
- r = self.connection.request(action,
- params={"api-version": "2015-06-15"})
- return [AzureSubnet(net["id"], net["name"], net["properties"])
- for net in r.object["value"]]
-
- def ex_list_nics(self, resource_group):
- """
- List available virtual network interface controllers
- in a resource group
-
- :param resource_group: List NICS in a specific resource group
- containing the NICs.
- :type resource_group: ``str``
-
- :return: A list of NICs.
- :rtype: ``list`` of :class:`.AzureNic`
- """
-
- action = "/subscriptions/%s/providers/Microsoft.Network" \
- "/networkInterfaces" % \
- (self.subscription_id, resource_group)
- r = self.connection.request(action,
- params={"api-version": "2015-06-15"})
- return [self._to_nic(net) for net in r.object["value"]]
-
- def ex_get_nic(self, id):
- """
- Fetch information about a NIC.
-
- :param id: The complete resource path to the NIC resource.
- :type id: ``str``
-
- :return: The NIC object
- :rtype: :class:`.AzureNic`
- """
-
- r = self.connection.request(id, params={"api-version": "2015-06-15"})
- return self._to_nic(r.object)
-
- def ex_get_public_ip(self, id):
- """
- Fetch information about a public IP resource.
-
- :param id: The complete resource path to the public IP resource.
- :type id: ``str`
-
- :return: The public ip object
- :rtype: :class:`.AzureIPAddress`
- """
-
- r = self.connection.request(id, params={"api-version": "2015-06-15"})
- return self._to_ip_address(r.object)
-
- def ex_list_public_ips(self, resource_group):
- """
- List public IP resources.
-
- :param resource_group: List public IPs in a specific resource group.
- :type resource_group: ``str``
-
- :return: List of public ip objects
- :rtype: ``list`` of :class:`.AzureIPAddress`
- """
-
- action = "/subscriptions/%s/providers/Microsoft.Network" \
- "/publicIPAddresses" % (self.subscription_id, resource_group)
- r = self.connection.request(action,
- params={"api-version": "2015-06-15"})
- return [self._to_ip_address(net) for net in r.object["value"]]
-
- def ex_create_public_ip(self, name, resource_group, location=None):
- """
- Create a public IP resources.
-
- :param name: Name of the public IP resource
- :type name: ``str``
-
- :param resource_group: The resource group to create the public IP
- :type resource_group: ``str``
-
- :param location: The location at which to create the public IP
- (if None, use default location specified as 'region' in __init__)
- :type location: :class:`.NodeLocation`
-
- :return: The newly created public ip object
- :rtype: :class:`.AzureIPAddress`
- """
-
- if location is None and self.default_location:
- location = self.default_location
- else:
- raise ValueError("location is required.")
-
- target = "/subscriptions/%s/resourceGroups/%s/" \
- "providers/Microsoft.Network/publicIPAddresses/%s" \
- % (self.subscription_id, resource_group, name)
- data = {
- "location": location.id,
- "tags": {},
- "properties": {
- "publicIPAllocationMethod": "Dynamic"
- }
- }
- r = self.connection.request(target,
- params={"api-version": "2015-06-15"},
- data=data,
- method='PUT'
- )
- return self._to_ip_address(r.object)
-
- def ex_create_network_interface(self, name, subnet, resource_group,
- location=None, public_ip=None):
- """
- Create a virtual network interface (NIC).
-
- :param name: Name of the NIC resource
- :type name: ``str``
-
- :param subnet: The subnet to attach the NIC
- :type subnet: :class:`.AzureSubnet`
-
- :param resource_group: The resource group to create the NIC
- :type resource_group: ``str``
-
- :param location: The location at which to create the NIC
- (if None, use default location specified as 'region' in __init__)
- :type location: :class:`.NodeLocation`
-
- :param public_ip: Associate a public IP resource with this NIC
- (optional).
- :type public_ip: :class:`.AzureIPAddress`
-
- :return: The newly created NIC
- :rtype: :class:`.AzureNic`
- """
-
- if location is None:
- if self.default_location:
- location = self.default_location
- else:
- raise ValueError("location is required.")
-
- target = "/subscriptions/%s/resourceGroups/%s/providers" \
- "/Microsoft.Network/networkInterfaces/%s" \
- % (self.subscription_id, resource_group, name)
-
- data = {
- "location": location.id,
- "tags": {},
- "properties": {
- "ipConfigurations": [{
- "name": "myip1",
- "properties": {
- "subnet": {
- "id": subnet.id
- },
- "privateIPAllocationMethod": "Dynamic"
- }
- }]
- }
- }
-
- if public_ip:
- data["properties"]["ipConfigurations"][0]["publicIPAddress"] = {
- "id": public_ip.id
- }
-
- r = self.connection.request(target,
- params={"api-version": "2015-06-15"},
- data=data,
- method='PUT'
- )
- return AzureNic(r.object["id"], r.object["name"], r.object["location"],
- r.object["properties"])
-
- def ex_create_tags(self, resource, tags, replace=False):
- """
- Update tags on any resource supporting tags.
-
- :param resource: The resource to update.
- :type resource: ``str`` or Azure object with an ``id`` attribute.
-
- :param tags: The tags to set.
- :type tags: ``dict``
-
- :param replace: If true, replace all tags with the new tags.
- If false (default) add or update tags.
- :type replace: ``bool``
- """
-
- if not isinstance(resource, basestring):
- resource = resource.id
- r = self.connection.request(
- resource,
- params={"api-version": "2015-06-15"})
- if replace:
- r.object["tags"] = tags
- else:
- r.object["tags"].update(tags)
- r = self.connection.request(resource, data={"tags": r.object["tags"]},
- params={"api-version": "2015-06-15"},
- method="PATCH")
-
- def ex_start_node(self, node):
- """
- Start a stopped node.
-
- :param node: The node to be started
- :type node: :class:`.Node`
- """
-
- target = "%s/start" % node.id
- r = self.connection.request(target,
- params={"api-version": "2015-06-15"},
- method='POST')
- return r.object
-
- def ex_stop_node(self, node, deallocate=True):
- """
- Stop a running node.
-
- :param node: The node to be stopped
- :type node: :class:`.Node`
-
- :param deallocate: If True (default) stop and then deallocate the node
- (release the hardware allocated to run the node). If False, stop the
- node but maintain the hardware allocation. If the node is not
- deallocated, the subscription will continue to be billed as if it
- were running.
- :type deallocate: ``bool``
- """
-
- if deallocate:
- target = "%s/deallocate" % node.id
- else:
- target = "%s/stop" % node.id
- r = self.connection.request(target,
- params={"api-version": "2015-06-15"},
- method='POST')
- return r.object
-
- def ex_get_storage_account_keys(self, resource_group, storage_account):
- """
- Get account keys required to access to a storage account
- (using AzureBlobsStorageDriver).
-
- :param resource_group: The resource group
- containing the storage account
- :type resource_group: ``str``
-
- :param storage_account: Storage account to access
- :type storage_account: ``str``
-
- :return: The account keys, in the form `{"key1": "XXX", "key2": "YYY"}`
- :rtype: ``.dict``
- """
-
- action = "/subscriptions/%s/resourceGroups/%s/" \
- "providers/Microsoft.Storage/storageAccounts/%s/listKeys" \
- % (self.subscription_id,
- resource_group,
- storage_account)
-
- r = self.connection.request(action,
- params={
- "api-version": "2015-05-01-preview"},
- method="POST")
- return r.object
-
- def ex_run_command(self, node,
- command,
- filerefs=[],
- timestamp=0,
- storage_account_name=None,
- storage_account_key=None,
- location=None):
- """
- Run a command on the node as root.
-
- Does not require ssh to log in,
- uses Windows Azure Agent (waagent) running
- on the node.
-
- :param node: The node on which to run the command.
- :type node: :class:``.Node``
-
- :param command: The actual command to run. Note this is parsed
- into separate arguments according to shell quoting rules but is
- executed directly as a subprocess, not a shell command.
- :type command: ``str``
-
- :param filerefs: Optional files to fetch by URI from Azure blob store
- (must provide storage_account_name and storage_account_key),
- or regular HTTP.
- :type command: ``list`` of ``str``
-
- :param location: The location of the virtual machine
- (if None, use default location specified as 'region' in __init__)
- :type location: :class:`.NodeLocation`
-
- :param storage_account_name: The storage account
- from which to fetch files in `filerefs`
- :type storage_account_name: ``str``
-
- :param storage_account_key: The storage key to
- authorize to the blob store.
- :type storage_account_key: ``str``
-
- :type: ``list`` of :class:`.NodeLocation`
-
- """
-
- if location is None:
- if self.default_location:
- location = self.default_location
- else:
- raise ValueError("location is required.")
-
- name = "init"
-
- target = node.id + "/extensions/" + name
-
- data = {
- "location": location.id,
- "name": name,
- "properties": {
- "publisher": "Microsoft.OSTCExtensions",
- "type": "CustomScriptForLinux",
- "typeHandlerVersion": "1.3",
- "settings": {
- "fileUris": filerefs,
- "commandToExecute": command,
- "timestamp": timestamp
- }
- }
- }
-
- if storage_account_name and storage_account_key:
- data["properties"]["protectedSettings"] = {
- "storageAccountName": storage_account_name,
- "storageAccountKey": storage_account_key}
-
- r = self.connection.request(target,
- params={"api-version": "2015-06-15"},
- data=data,
- method='PUT')
- return r.object
-
- def _ex_delete_old_vhd(self, resource_group, uri):
- try:
- (storageAccount, blobContainer, blob) = _split_blob_uri(uri)
- keys = self.ex_get_storage_account_keys(resource_group,
- storageAccount)
- blobdriver = AzureBlobsStorageDriver(storageAccount,
- keys["key1"])
- blobdriver.delete_object(blobdriver.get_object(blobContainer,
- blob))
- return True
- except ObjectDoesNotExistError:
- return True
-
- def _ex_connection_class_kwargs(self):
- kwargs = super(AzureNodeDriver, self)._ex_connection_class_kwargs()
- kwargs['tenant_id'] = self.tenant_id
- kwargs['subscription_id'] = self.subscription_id
- return kwargs
-
- def _to_node(self, data, fetch_nic=True):
- private_ips = []
- public_ips = []
- nics = data["properties"]["networkProfile"]["networkInterfaces"]
- if fetch_nic:
- for nic in nics:
- try:
- n = self.ex_get_nic(nic["id"])
- priv = n.extra["ipConfigurations"][0]["properties"] \
- .get("privateIPAddress")
- if priv:
- private_ips.append(priv)
- pub = n.extra["ipConfigurations"][0]["properties"].get(
- "publicIPAddress")
- if pub:
- pub_addr = self.ex_get_public_ip(pub["id"])
- addr = pub_addr.extra.get("ipAddress")
- if addr:
- public_ips.append(addr)
- except BaseHTTPError:
- pass
-
- state = NodeState.UNKNOWN
- try:
- action = "%s/InstanceView" % (data["id"])
- r = self.connection.request(action,
- params={"api-version": "2015-06-15"})
- for status in r.object["statuses"]:
- if status["code"] == "ProvisioningState/creating":
- state = NodeState.PENDING
- break
- elif status["code"] == "ProvisioningState/deleting":
- state = NodeState.TERMINATED
- break
- elif status["code"].startswith("ProvisioningState/failed"):
- state = NodeState.ERROR
- break
- elif status["code"] == "ProvisioningState/succeeded":
- pass
-
- if status["code"] == "PowerState/deallocated":
- state = NodeState.STOPPED
- break
- elif status["code"] == "PowerState/deallocating":
- state = NodeState.PENDING
- break
- elif status["code"] == "PowerState/running":
- state = NodeState.RUNNING
- except BaseHTTPError:
- pass
-
- node = Node(data["id"],
- data["name"],
- state,
- public_ips,
- private_ips,
- driver=self.connection.driver,
- extra=data)
-
- return node
-
- def _to_node_size(self, data):
- return NodeSize(id=data["name"],
- name=data["name"],
- ram=data["memoryInMB"],
- # convert to disk from MB to GB
- disk=data["resourceDiskSizeInMB"] / 1024,
- bandwidth=0,
- price=0,
- driver=self.connection.driver,
- extra={"numberOfCores": data["numberOfCores"],
- "osDiskSizeInMB": data["osDiskSizeInMB"],
- "maxDataDiskCount": data["maxDataDiskCount"]})
-
- def _to_nic(self, data):
- return AzureNic(data["id"], data["name"], data["location"],
- data["properties"])
-
- def _to_ip_address(self, data):
- return AzureIPAddress(data["id"], data["name"], data["properties"])
-
- def _to_location(self, loc):
- # XXX for some reason the API returns location names like
- # "East US" instead of "eastus" which is what is actually needed
- # for other API calls, so do a name->id fixup.
- loc_id = loc.lower().replace(" ", "")
- return NodeLocation(loc_id, loc, self._location_to_country.get(loc_id),
- self.connection.driver)
-
-
-def _split_blob_uri(uri):
- uri = uri.split("/")
- storageAccount = uri[2].split(".")[0]
- blobContainer = uri[3]
- blob = '/'.join(uri[4:])
- return (storageAccount, blobContainer, blob)
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/bluebox.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/bluebox.py b/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/bluebox.py
deleted file mode 100644
index 204e0de..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/bluebox.py
+++ /dev/null
@@ -1,235 +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.
-
-"""
-libcloud driver for the Blue Box Blocks API
-
-This driver implements all libcloud functionality for the Blue Box Blocks API.
-
-Blue Box home page http://bluebox.net
-Blue Box API documentation https://boxpanel.bluebox
-.net/public/the_vault/index.php/Blocks_API
-"""
-
-import copy
-import base64
-
-from libcloud.utils.py3 import urlencode
-from libcloud.utils.py3 import b
-
-from libcloud.common.base import JsonResponse, ConnectionUserAndKey
-from libcloud.compute.providers import Provider
-from libcloud.compute.types import NodeState, InvalidCredsError
-from libcloud.compute.base import Node, NodeDriver
-from libcloud.compute.base import NodeSize, NodeImage, NodeLocation
-from libcloud.compute.base import NodeAuthPassword, NodeAuthSSHKey
-
-# Current end point for Blue Box API.
-BLUEBOX_API_HOST = "boxpanel.bluebox.net"
-
-# The API doesn't currently expose all of the required values for libcloud,
-# so we simply list what's available right now, along with all of the various
-# attributes that are needed by libcloud.
-BLUEBOX_INSTANCE_TYPES = {
- '1gb': {
- 'id': '94fd37a7-2606-47f7-84d5-9000deda52ae',
- 'name': 'Block 1GB Virtual Server',
- 'ram': 1024,
- 'disk': 20,
- 'cpu': 0.5
- },
- '2gb': {
- 'id': 'b412f354-5056-4bf0-a42f-6ddd998aa092',
- 'name': 'Block 2GB Virtual Server',
- 'ram': 2048,
- 'disk': 25,
- 'cpu': 1
- },
- '4gb': {
- 'id': '0cd183d3-0287-4b1a-8288-b3ea8302ed58',
- 'name': 'Block 4GB Virtual Server',
- 'ram': 4096,
- 'disk': 50,
- 'cpu': 2
- },
- '8gb': {
- 'id': 'b9b87a5b-2885-4a2e-b434-44a163ca6251',
- 'name': 'Block 8GB Virtual Server',
- 'ram': 8192,
- 'disk': 100,
- 'cpu': 4
- }
-}
-
-RAM_PER_CPU = 2048
-
-NODE_STATE_MAP = {'queued': NodeState.PENDING,
- 'building': NodeState.PENDING,
- 'running': NodeState.RUNNING,
- 'error': NodeState.TERMINATED,
- 'unknown': NodeState.UNKNOWN}
-
-
-class BlueboxResponse(JsonResponse):
- def parse_error(self):
- if int(self.status) == 401:
- if not self.body:
- raise InvalidCredsError(str(self.status) + ': ' + self.error)
- else:
- raise InvalidCredsError(self.body)
- return self.body
-
-
-class BlueboxNodeSize(NodeSize):
- def __init__(self, id, name, cpu, ram, disk, price, driver):
- self.id = id
- self.name = name
- self.cpu = cpu
- self.ram = ram
- self.disk = disk
- self.price = price
- self.driver = driver
-
- def __repr__(self):
- return ((
- '<NodeSize: id=%s, name=%s, cpu=%s, ram=%s, disk=%s, '
- 'price=%s, driver=%s ...>')
- % (self.id, self.name, self.cpu, self.ram, self.disk,
- self.price, self.driver.name))
-
-
-class BlueboxConnection(ConnectionUserAndKey):
- """
- Connection class for the Bluebox driver
- """
-
- host = BLUEBOX_API_HOST
- secure = True
- responseCls = BlueboxResponse
-
- allow_insecure = False
-
- def add_default_headers(self, headers):
- user_b64 = base64.b64encode(b('%s:%s' % (self.user_id, self.key)))
- headers['Authorization'] = 'Basic %s' % (user_b64)
- return headers
-
-
-class BlueboxNodeDriver(NodeDriver):
- """
- Bluebox Blocks node driver
- """
-
- connectionCls = BlueboxConnection
- type = Provider.BLUEBOX
- api_name = 'bluebox'
- name = 'Bluebox Blocks'
- website = 'http://bluebox.net'
- features = {'create_node': ['ssh_key', 'password']}
-
- def list_nodes(self):
- result = self.connection.request('/api/blocks.json')
- return [self._to_node(i) for i in result.object]
-
- def list_sizes(self, location=None):
- sizes = []
- for key, values in list(BLUEBOX_INSTANCE_TYPES.items()):
- attributes = copy.deepcopy(values)
- attributes.update({'price': self._get_size_price(size_id=key)})
- sizes.append(BlueboxNodeSize(driver=self.connection.driver,
- **attributes))
-
- return sizes
-
- def list_images(self, location=None):
- result = self.connection.request('/api/block_templates.json')
- images = []
- for image in result.object:
- images.extend([self._to_image(image)])
-
- return images
-
- def create_node(self, **kwargs):
- headers = {'Content-Type': 'application/x-www-form-urlencoded'}
- size = kwargs["size"]
-
- name = kwargs['name']
- image = kwargs['image']
- size = kwargs['size']
-
- auth = self._get_and_check_auth(kwargs.get('auth'))
-
- data = {
- 'hostname': name,
- 'product': size.id,
- 'template': image.id
- }
-
- ssh = None
- password = None
-
- if isinstance(auth, NodeAuthSSHKey):
- ssh = auth.pubkey
- data.update(ssh_public_key=ssh)
- elif isinstance(auth, NodeAuthPassword):
- password = auth.password
- data.update(password=password)
-
- if "ex_username" in kwargs:
- data.update(username=kwargs["ex_username"])
-
- if not ssh and not password:
- raise Exception("SSH public key or password required.")
-
- params = urlencode(data)
- result = self.connection.request('/api/blocks.json', headers=headers,
- data=params, method='POST')
- node = self._to_node(result.object)
-
- if getattr(auth, "generated", False):
- node.extra['password'] = auth.password
-
- return node
-
- def destroy_node(self, node):
- url = '/api/blocks/%s.json' % (node.id)
- result = self.connection.request(url, method='DELETE')
-
- return result.status == 200
-
- def list_locations(self):
- return [NodeLocation(0, "Blue Box Seattle US", 'US', self)]
-
- def reboot_node(self, node):
- url = '/api/blocks/%s/reboot.json' % (node.id)
- result = self.connection.request(url, method="PUT")
- return result.status == 200
-
- def _to_node(self, vm):
- state = NODE_STATE_MAP[vm.get('status', NodeState.UNKNOWN)]
- n = Node(id=vm['id'],
- name=vm['hostname'],
- state=state,
- public_ips=[ip['address'] for ip in vm['ips']],
- private_ips=[],
- extra={'storage': vm['storage'], 'cpu': vm['cpu']},
- driver=self.connection.driver)
- return n
-
- def _to_image(self, image):
- image = NodeImage(id=image['id'],
- name=image['description'],
- driver=self.connection.driver)
- return image
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/brightbox.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/brightbox.py b/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/brightbox.py
deleted file mode 100644
index 8798332..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/brightbox.py
+++ /dev/null
@@ -1,306 +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.
-"""
-Brightbox Driver
-"""
-
-from libcloud.utils.py3 import httplib
-from libcloud.utils.py3 import b
-
-from libcloud.common.brightbox import BrightboxConnection
-from libcloud.compute.types import Provider, NodeState
-from libcloud.compute.base import NodeDriver
-from libcloud.compute.base import Node, NodeImage, NodeSize, NodeLocation
-
-import base64
-
-
-API_VERSION = '1.0'
-
-
-def _extract(d, keys):
- return dict((k, d[k]) for k in keys if k in d and d[k] is not None)
-
-
-class BrightboxNodeDriver(NodeDriver):
- """
- Brightbox node driver
- """
-
- connectionCls = BrightboxConnection
-
- type = Provider.BRIGHTBOX
- name = 'Brightbox'
- website = 'http://www.brightbox.co.uk/'
-
- NODE_STATE_MAP = {'creating': NodeState.PENDING,
- 'active': NodeState.RUNNING,
- 'inactive': NodeState.UNKNOWN,
- 'deleting': NodeState.UNKNOWN,
- 'deleted': NodeState.TERMINATED,
- 'failed': NodeState.UNKNOWN,
- 'unavailable': NodeState.UNKNOWN}
-
- def __init__(self, key, secret=None, secure=True, host=None, port=None,
- api_version=API_VERSION, **kwargs):
- super(BrightboxNodeDriver, self).__init__(key=key, secret=secret,
- secure=secure,
- host=host, port=port,
- api_version=api_version,
- **kwargs)
-
- def _to_node(self, data):
- extra_data = _extract(data, ['fqdn', 'user_data', 'status',
- 'interfaces', 'snapshots',
- 'server_groups', 'hostname',
- 'started_at', 'created_at',
- 'deleted_at'])
- extra_data['zone'] = self._to_location(data['zone'])
-
- ipv6_addresses = [interface['ipv6_address'] for interface
- in data['interfaces'] if 'ipv6_address' in interface]
-
- private_ips = [interface['ipv4_address']
- for interface in data['interfaces']
- if 'ipv4_address' in interface]
-
- public_ips = [cloud_ip['public_ip'] for cloud_ip in data['cloud_ips']]
- public_ips += ipv6_addresses
-
- return Node(
- id=data['id'],
- name=data['name'],
- state=self.NODE_STATE_MAP[data['status']],
- private_ips=private_ips,
- public_ips=public_ips,
- driver=self.connection.driver,
- size=self._to_size(data['server_type']),
- image=self._to_image(data['image']),
- extra=extra_data
- )
-
- def _to_image(self, data):
- extra_data = _extract(data, ['arch', 'compatibility_mode',
- 'created_at', 'description',
- 'disk_size', 'min_ram', 'official',
- 'owner', 'public', 'source',
- 'source_type', 'status', 'username',
- 'virtual_size', 'licence_name'])
-
- if data.get('ancestor', None):
- extra_data['ancestor'] = self._to_image(data['ancestor'])
-
- return NodeImage(
- id=data['id'],
- name=data['name'],
- driver=self,
- extra=extra_data
- )
-
- def _to_size(self, data):
- return NodeSize(
- id=data['id'],
- name=data['name'],
- ram=data['ram'],
- disk=data['disk_size'],
- bandwidth=0,
- price=0,
- driver=self
- )
-
- def _to_location(self, data):
- if data:
- return NodeLocation(
- id=data['id'],
- name=data['handle'],
- country='GB',
- driver=self
- )
- else:
- return None
-
- def _post(self, path, data={}):
- headers = {'Content-Type': 'application/json'}
- return self.connection.request(path, data=data, headers=headers,
- method='POST')
-
- def _put(self, path, data={}):
- headers = {'Content-Type': 'application/json'}
- return self.connection.request(path, data=data, headers=headers,
- method='PUT')
-
- def create_node(self, **kwargs):
- """Create a new Brightbox node
-
- Reference: https://api.gb1.brightbox.com/1.0/#server_create_server
-
- @inherits: :class:`NodeDriver.create_node`
-
- :keyword ex_userdata: User data
- :type ex_userdata: ``str``
-
- :keyword ex_servergroup: Name or list of server group ids to
- add server to
- :type ex_servergroup: ``str`` or ``list`` of ``str``
- """
- data = {
- 'name': kwargs['name'],
- 'server_type': kwargs['size'].id,
- 'image': kwargs['image'].id,
- }
-
- if 'ex_userdata' in kwargs:
- data['user_data'] = base64.b64encode(b(kwargs['ex_userdata'])) \
- .decode('ascii')
-
- if 'location' in kwargs:
- data['zone'] = kwargs['location'].id
-
- if 'ex_servergroup' in kwargs:
- if not isinstance(kwargs['ex_servergroup'], list):
- kwargs['ex_servergroup'] = [kwargs['ex_servergroup']]
- data['server_groups'] = kwargs['ex_servergroup']
-
- data = self._post('/%s/servers' % self.api_version, data).object
- return self._to_node(data)
-
- def destroy_node(self, node):
- response = self.connection.request(
- '/%s/servers/%s' % (self.api_version, node.id),
- method='DELETE')
- return response.status == httplib.ACCEPTED
-
- def list_nodes(self):
- data = self.connection.request('/%s/servers' % self.api_version).object
- return list(map(self._to_node, data))
-
- def list_images(self, location=None):
- data = self.connection.request('/%s/images' % self.api_version).object
- return list(map(self._to_image, data))
-
- def list_sizes(self):
- data = self.connection.request('/%s/server_types' % self.api_version) \
- .object
- return list(map(self._to_size, data))
-
- def list_locations(self):
- data = self.connection.request('/%s/zones' % self.api_version).object
- return list(map(self._to_location, data))
-
- def ex_list_cloud_ips(self):
- """
- List Cloud IPs
-
- @note: This is an API extension for use on Brightbox
-
- :rtype: ``list`` of ``dict``
- """
- return self.connection.request('/%s/cloud_ips' % self.api_version) \
- .object
-
- def ex_create_cloud_ip(self, reverse_dns=None):
- """
- Requests a new cloud IP address for the account
-
- @note: This is an API extension for use on Brightbox
-
- :param reverse_dns: Reverse DNS hostname
- :type reverse_dns: ``str``
-
- :rtype: ``dict``
- """
- params = {}
-
- if reverse_dns:
- params['reverse_dns'] = reverse_dns
-
- return self._post('/%s/cloud_ips' % self.api_version, params).object
-
- def ex_update_cloud_ip(self, cloud_ip_id, reverse_dns):
- """
- Update some details of the cloud IP address
-
- @note: This is an API extension for use on Brightbox
-
- :param cloud_ip_id: The id of the cloud ip.
- :type cloud_ip_id: ``str``
-
- :param reverse_dns: Reverse DNS hostname
- :type reverse_dns: ``str``
-
- :rtype: ``dict``
- """
- response = self._put('/%s/cloud_ips/%s' % (self.api_version,
- cloud_ip_id),
- {'reverse_dns': reverse_dns})
- return response.status == httplib.OK
-
- def ex_map_cloud_ip(self, cloud_ip_id, interface_id):
- """
- Maps (or points) a cloud IP address at a server's interface
- or a load balancer to allow them to respond to public requests
-
- @note: This is an API extension for use on Brightbox
-
- :param cloud_ip_id: The id of the cloud ip.
- :type cloud_ip_id: ``str``
-
- :param interface_id: The Interface ID or LoadBalancer ID to
- which this Cloud IP should be mapped to
- :type interface_id: ``str``
-
- :return: True if the mapping was successful.
- :rtype: ``bool``
- """
- response = self._post('/%s/cloud_ips/%s/map' % (self.api_version,
- cloud_ip_id),
- {'destination': interface_id})
- return response.status == httplib.ACCEPTED
-
- def ex_unmap_cloud_ip(self, cloud_ip_id):
- """
- Unmaps a cloud IP address from its current destination making
- it available to remap. This remains in the account's pool
- of addresses
-
- @note: This is an API extension for use on Brightbox
-
- :param cloud_ip_id: The id of the cloud ip.
- :type cloud_ip_id: ``str``
-
- :return: True if the unmap was successful.
- :rtype: ``bool``
- """
- response = self._post('/%s/cloud_ips/%s/unmap' % (self.api_version,
- cloud_ip_id))
- return response.status == httplib.ACCEPTED
-
- def ex_destroy_cloud_ip(self, cloud_ip_id):
- """
- Release the cloud IP address from the account's ownership
-
- @note: This is an API extension for use on Brightbox
-
- :param cloud_ip_id: The id of the cloud ip.
- :type cloud_ip_id: ``str``
-
- :return: True if the unmap was successful.
- :rtype: ``bool``
- """
- response = self.connection.request(
- '/%s/cloud_ips/%s' % (self.api_version,
- cloud_ip_id),
- method='DELETE')
- return response.status == httplib.OK
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/bsnl.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/bsnl.py b/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/bsnl.py
deleted file mode 100644
index 6353671..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/bsnl.py
+++ /dev/null
@@ -1,53 +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.common.dimensiondata import (DimensionDataConnection,
- API_ENDPOINTS)
-from libcloud.compute.drivers.dimensiondata import DimensionDataNodeDriver
-
-DEFAULT_REGION = 'bsnl-in'
-
-
-class BSNLNodeDriver(DimensionDataNodeDriver):
- """
- BSNL node driver, based on Dimension Data driver
- """
-
- selected_region = None
- connectionCls = DimensionDataConnection
- name = 'BSNL'
- website = 'http://www.bsnlcloud.com/'
- type = Provider.BSNL
- features = {'create_node': ['password']}
- api_version = 1.0
-
- 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(BSNLNodeDriver, self).__init__(
- key=key,
- secret=secret,
- secure=secure,
- host=host,
- port=port,
- api_version=api_version,
- region=region,
- **kwargs)
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/ciscoccs.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/ciscoccs.py b/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/ciscoccs.py
deleted file mode 100644
index adc21f1..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/compute/drivers/ciscoccs.py
+++ /dev/null
@@ -1,56 +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.
-"""
-Cisco CCS Driver
-"""
-
-from libcloud.compute.providers import Provider
-from libcloud.common.dimensiondata import (DimensionDataConnection,
- API_ENDPOINTS)
-from libcloud.compute.drivers.dimensiondata import DimensionDataNodeDriver
-
-DEFAULT_REGION = 'cisco-na'
-
-
-class CiscoCCSNodeDriver(DimensionDataNodeDriver):
- """
- Cisco CCS node driver, based on Dimension Data driver
- """
-
- selected_region = None
- connectionCls = DimensionDataConnection
- name = 'CiscoCCS'
- website = 'http://www.cisco.com/'
- type = Provider.CISCOCCS
- features = {'create_node': ['password']}
- api_version = 1.0
-
- 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(CiscoCCSNodeDriver, self).__init__(
- key=key,
- secret=secret,
- secure=secure,
- host=host,
- port=port,
- api_version=api_version,
- region=region,
- **kwargs)