Source code for libcloud.compute.drivers.gig_g8

# 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
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.
GiG G8 Driver

import json
from libcloud.compute.base import NodeImage, NodeSize, Node
from libcloud.compute.base import NodeDriver, UuidMixin
from libcloud.compute.base import StorageVolume, NodeAuthSSHKey
from libcloud.compute.types import Provider, NodeState
from libcloud.common.gig_g8 import G8Connection
from libcloud.common.exceptions import BaseHTTPError

[docs]class G8ProvisionError(Exception): pass
[docs]class G8PortForward(UuidMixin): def __init__(self, network, node_id, publicport, privateport, protocol, driver): self.node_id = node_id = network self.publicport = int(publicport) self.privateport = int(privateport) self.protocol = protocol self.driver = driver UuidMixin.__init__(self)
[docs] def destroy(self): self.driver.ex_delete_portforward(self)
[docs]class G8Network(UuidMixin): """ G8 Network object class. This class maps to a cloudspace """ def __init__(self, id, name, cidr, publicipaddress, driver, extra=None): = id = name self._cidr = cidr self.driver = driver self.publicipaddress = publicipaddress self.extra = extra UuidMixin.__init__(self) @property def cidr(self): """ Cidr is not part of the list result we will lazily fetch it with a get request """ if self._cidr is None: networkdata = self.driver._api_request( "/cloudspaces/get", {"cloudspaceId":} ) self._cidr = networkdata["privatenetwork"] return self._cidr
[docs] def list_nodes(self): return self.driver.list_nodes(self)
[docs] def destroy(self): return self.driver.ex_destroy_network(self)
[docs] def list_portforwards(self): return self.driver.ex_list_portforwards(self)
[docs] def create_portforward(self, node, publicport, privateport, protocol="tcp"): return self.driver.ex_create_portforward( self, node, publicport, privateport, protocol )
[docs]class G8NodeDriver(NodeDriver): """ GiG G8 node driver """ NODE_STATE_MAP = { "VIRTUAL": NodeState.PENDING, "HALTED": NodeState.STOPPED, "RUNNING": NodeState.RUNNING, "DESTROYED": NodeState.TERMINATED, "DELETED": NodeState.TERMINATED, "PAUSED": NodeState.PAUSED, "ERROR": NodeState.ERROR, # transition states "DEPLOYING": NodeState.PENDING, "STOPPING": NodeState.STOPPING, "MOVING": NodeState.MIGRATING, "RESTORING": NodeState.PENDING, "STARTING": NodeState.STARTING, "PAUSING": NodeState.PENDING, "RESUMING": NodeState.PENDING, "RESETTING": NodeState.REBOOTING, "DELETING": NodeState.TERMINATED, "DESTROYING": NodeState.TERMINATED, "ADDING_DISK": NodeState.RECONFIGURING, "ATTACHING_DISK": NodeState.RECONFIGURING, "DETACHING_DISK": NodeState.RECONFIGURING, "ATTACHING_NIC": NodeState.RECONFIGURING, "DETTACHING_NIC": NodeState.RECONFIGURING, "DELETING_DISK": NodeState.RECONFIGURING, "CHANGING_DISK_LIMITS": NodeState.RECONFIGURING, "CLONING": NodeState.PENDING, "RESIZING": NodeState.RECONFIGURING, "CREATING_TEMPLATE": NodeState.PENDING, } name = "GiG G8 Node Provider" website = "" type = Provider.GIG_G8 connectionCls = G8Connection def __init__(self, user_id, key, api_url): # type (int, str, str) -> None """ :param key: Token to use for api (jwt) :type key: ``str`` :param user_id: Id of the account to connect to (accountId) :type user_id: ``int`` :param api_url: G8 api url :type api_url: ``str`` :rtype: ``None`` """ self._apiurl = api_url.rstrip("/") super(G8NodeDriver, self).__init__(key=key) self._account_id = user_id self._location_data = None def _ex_connection_class_kwargs(self): return {"url": self._apiurl} def _api_request(self, endpoint, params=None): return self.connection.request( endpoint.lstrip("/"), data=json.dumps(params), method="POST" ).object @property def _location(self): if self._location_data is None: self._location_data = self._api_request("/locations/list")[0] return self._location_data
[docs] def create_node( self, name, image, ex_network, ex_description, size=None, auth=None, ex_create_attr=None, ex_expose_ssh=False, ): # type (str, Image, G8Network, str, Size, # Optional[NodeAuthSSHKey], Optional[Dict], bool) -> Node """ Create a node. The `ex_create_attr` parameter can include the following dictionary key and value pairs: * `memory`: ``int`` Memory in MiB (only used if size is None and vcpus is passed * `vcpus`: ``int`` Amount of vcpus (only used if size is None and memory is passed) * `disk_size`: ``int`` Size of bootdisk defaults to minimumsize of the image * `user_data`: ``str`` for cloud-config data * `private_ip`: ``str`` Private Ip inside network * `data_disks`: ``list(int)`` Extra data disks to assign to vm list of disk sizes in GiB :param name: the name to assign the vm :type name: ``str`` :param size: the plan size to create mutual exclusive with `memory` `vcpus` :type size: :class:`NodeSize` :param image: which distribution to deploy on the vm :type image: :class:`NodeImage` :param network: G8 Network to place vm in :type size: :class:`G8Network` :param ex_description: Descripton of vm :type size: : ``str`` :param auth: an SSH key :type auth: :class:`NodeAuthSSHKey` :param ex_create_attr: A dictionary of optional attributes for vm creation :type ex_create_attr: ``dict`` :param ex_expose_ssh: Create portforward for ssh port :type ex_expose_ssh: int :return: The newly created node. :rtype: :class:`Node` """ params = { "name": name, "imageId": int(, "cloudspaceId": int(, "description": ex_description, } ex_create_attr = ex_create_attr or {} if size: params["sizeId"] = int( else: params["memory"] = ex_create_attr["memory"] params["vcpus"] = ex_create_attr["vcpus"] if "user_data" in ex_create_attr: params["userdata"] = ex_create_attr["user_data"] if "data_disks" in ex_create_attr: params["datadisks"] = ex_create_attr["data_disks"] if "private_ip" in ex_create_attr: params["privateIp"] = ex_create_attr["private_ip"] if "disk_size" in ex_create_attr: params["disksize"] = ex_create_attr["disk_size"] else: params["disksize"] = image.extra["min_disk_size"] if auth and isinstance(auth, NodeAuthSSHKey): userdata = params.setdefault("userdata", {}) users = userdata.setdefault("users", []) root = None for user in users: if user["name"] == "root": root = user break else: root = {"name": "root", "shell": "/bin/bash"} users.append(root) keys = root.setdefault("ssh-authorized-keys", []) keys.append(auth.pubkey) elif auth: error = "Auth type {} is not implemented".format(type(auth)) raise NotImplementedError(error) machineId = self._api_request("/machines/create", params) machine = self._api_request("/machines/get", params={"machineId": machineId}) node = self._to_node(machine, ex_network) if ex_expose_ssh: port = self.ex_expose_ssh_node(node) node.extra["ssh_port"] = port node.extra["ssh_ip"] = ex_network.publicipaddress return node
def _find_ssh_ports(self, ex_network, node): forwards = ex_network.list_portforwards() usedports = [] result = {"node": None, "network": usedports} for forward in forwards: usedports.append(forward.publicport) if forward.node_id == and forward.privateport == 22: result["node"] = forward.privateport return result
[docs] def ex_expose_ssh_node(self, node): """ Create portforward for ssh purposed :param node: Node to expose ssh for :type node: ``Node`` :rtype: ``int`` """ network = node.extra["network"] ports = self._find_ssh_ports(network, node) if ports["node"]: return ports["node"] usedports = ports["network"] sshport = 2200 endport = 3000 while sshport < endport: while sshport in usedports: sshport += 1 try: network.create_portforward(node, sshport, 22) node.extra["ssh_port"] = sshport node.extra["ssh_ip"] = network.publicipaddress break except BaseHTTPError as e: if e.code == 409: # port already used maybe raise let's try next usedports.append(sshport) raise else: raise G8ProvisionError("Failed to create portforward") return sshport
[docs] def ex_create_network(self, name, private_network="", type="vgw"): # type (str, str, str) -> G8Network """ Create network also known as cloudspace :param name: the name to assing to the network :type name: ``str`` :param private_network: subnet used as private network :type private_network: ``str`` :param type: type of the gateway vgw or routeros :type type: ``str`` """ userinfo = self._api_request("../system/usermanager/whoami") params = { "accountId": self._account_id, "privatenetwork": private_network, "access": userinfo["name"], "name": name, "location": self._location["locationCode"], "type": type, } networkid = self._api_request("/cloudspaces/create", params) network = self._api_request("/cloudspaces/get", {"cloudspaceId": networkid}) return self._to_network(network)
[docs] def ex_destroy_network(self, network): # type (G8Network) -> bool self._api_request("/cloudspaces/delete", {"cloudspaceId": int(}) return True
[docs] def stop_node(self, node): # type (Node) -> bool """ Stop virtual machine """ node.state = NodeState.STOPPING self._api_request("/machines/stop", {"machineId": int(}) node.state = NodeState.STOPPED return True
[docs] def ex_list_portforwards(self, network): # type (G8Network) -> List[G8PortForward] data = self._api_request( "/portforwarding/list", {"cloudspaceId": int(} ) forwards = [] for forward in data: forwards.append(self._to_port_forward(forward, network)) return forwards
[docs] def ex_create_portforward( self, network, node, publicport, privateport, protocol="tcp" ): # type (G8Network, Node, int, int, str) -> G8PortForward params = { "cloudspaceId": int(, "machineId": int(, "localPort": privateport, "publicPort": publicport, "publicIp": network.publicipaddress, "protocol": protocol, } self._api_request("/portforwarding/create", params) return self._to_port_forward(params, network)
[docs] def ex_delete_portforward(self, portforward): # type (G8PortForward) -> bool params = { "cloudspaceId": int(, "publicIp":, "publicPort": portforward.publicport, "proto": portforward.protocol, } self._api_request("/portforwarding/deleteByPort", params) return True
[docs] def start_node(self, node): # type (Node) -> bool """ Start virtual machine """ node.state = NodeState.STARTING self._api_request("/machines/start", {"machineId": int(}) node.state = NodeState.RUNNING return True
[docs] def ex_list_networks(self): # type () -> List[G8Network] """ Return the list of networks. :return: A list of network objects. :rtype: ``list`` of :class:`G8Network` """ networks = [] for network in self._api_request("/cloudspaces/list"): if network["accountId"] == self._account_id: networks.append(self._to_network(network)) return networks
[docs] def list_sizes(self): # type () -> List[Size] """ Returns a list of node sizes as a cloud provider might have """ location = self._location["locationCode"] sizes = [] for size in self._api_request("/sizes/list", {"location": location}): sizes.extend(self._to_size(size)) return sizes
[docs] def list_nodes(self, ex_network=None): # type (Optional[G8Network]) -> List[Node] """ List the nodes known to a particular driver; There are two default nodes created at the beginning """ def _get_ssh_port(forwards, node): for forward in forwards: if forward.node_id == and forward.privateport == 22: return forward if ex_network: networks = [ex_network] else: networks = self.ex_list_networks() nodes = [] for network in networks: nodes_list = self._api_request( "/machines/list", params={"cloudspaceId":} ) forwards = network.list_portforwards() for nodedata in nodes_list: node = self._to_node(nodedata, network) sshforward = _get_ssh_port(forwards, node) if sshforward: node.extra["ssh_port"] = sshforward.publicport node.extra["ssh_ip"] = network.publicipaddress nodes.append(node) return nodes
[docs] def reboot_node(self, node): # type (Node) -> bool """ Reboot node returns True as if the reboot had been successful. """ node.state = NodeState.REBOOTING self._api_request("/machines/reboot", {"machineId": int(}) node.state = NodeState.RUNNING return True
[docs] def destroy_node(self, node): # type (Node) -> bool """ Destroy node """ self._api_request("/machines/delete", {"machineId": int(}) return True
[docs] def list_images(self): # type () -> List[Image] """ Returns a list of images as a cloud provider might have @inherits: :class:`NodeDriver.list_images` """ images = [] for image in self._api_request("/images/list", {"accountId": self._account_id}): images.append(self._to_image(image)) return images
[docs] def list_volumes(self): # type () -> List[StorageVolume] volumes = [] for disk in self._api_request("/disks/list", {"accountId": self._account_id}): if disk["status"] not in ["ASSIGNED", "CREATED"]: continue volumes.append(self._to_volume(disk)) return volumes
[docs] def create_volume(self, size, name, ex_description, ex_disk_type="D"): # type (int, str, str, Optional[str]) -> StorageVolume """ Create volume :param size: Size of the volume to create in GiB :type size: ``int`` :param name: Name of the volume :type name: ``str`` :param description: Descripton of the volume :type description: ``str`` :param disk_type: Type of the disk depending on the G8 D for datadisk is always available :type disk_type: ``str`` :rtype: class:`StorageVolume` """ params = { "size": size, "name": name, "type": ex_disk_type, "description": ex_description, "gid": self._location["gid"], "accountId": self._account_id, } diskId = self._api_request("/disks/create", params) disk = self._api_request("/disks/get", {"diskId": diskId}) return self._to_volume(disk)
[docs] def destroy_volume(self, volume): # type (StorageVolume) -> bool self._api_request("/disks/delete", {"diskId": int(}) return True
[docs] def attach_volume(self, node, volume): # type (Node, StorageVolume) -> bool params = {"machineId": int(, "diskId": int(} self._api_request("/machines/attachDisk", params) return True
[docs] def detach_volume(self, node, volume): # type (Node, StorageVolume) -> bool params = {"machineId": int(, "diskId": int(} self._api_request("/machines/detachDisk", params) return True
def _to_volume(self, data): # type (dict) -> StorageVolume extra = {"type": data["type"], "node_id": data.get("machineId")} return StorageVolume( id=str(data["id"]), size=data["sizeMax"], name=data["name"], driver=self, extra=extra, ) def _to_node(self, nodedata, ex_network): # type (dict) -> Node state = self.NODE_STATE_MAP.get(nodedata["status"], NodeState.UNKNOWN) public_ips = [] private_ips = [] nics = nodedata.get("nics", []) if not nics: nics = nodedata.get("interfaces", []) for nic in nics: if nic["type"] == "PUBLIC": public_ips.append(nic["ipAddress"].split("/")[0]) else: private_ips.append(nic["ipAddress"]) extra = {"network": ex_network} for account in nodedata.get("accounts", []): extra["password"] = account["password"] extra["username"] = account["login"] return Node( id=str(nodedata["id"]), name=nodedata["name"], driver=self, public_ips=public_ips, private_ips=private_ips, state=state, extra=extra, ) def _to_network(self, network): # type (dict) -> G8Network return G8Network( str(network["id"]), network["name"], None, network["externalnetworkip"], self, ) def _to_image(self, image): # type (dict) -> Image extra = { "min_disk_size": image["bootDiskSize"], "min_memory": image["memory"], } return NodeImage( id=str(image["id"]), name=image["name"], driver=self, extra=extra ) def _to_size(self, size): # type (dict) -> Size sizes = [] for disk in size["disks"]: sizes.append( NodeSize( id=str(size["id"]), name=size["name"], ram=size["memory"], disk=disk, driver=self, extra={"vcpus": size["vcpus"]}, bandwidth=0, price=0, ) ) return sizes def _to_port_forward(self, data, ex_network): # type (dict, G8Network) -> G8PortForward return G8PortForward( ex_network, str(data["machineId"]), data["publicPort"], data["localPort"], data["protocol"], self, )
if __name__ == "__main__": import doctest doctest.testmod()