Source code for libcloud.compute.drivers.kamatera

# 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.
Kamatera node driver
import json
import time
import datetime

from libcloud.utils.py3 import basestring
from libcloud.common.base import JsonResponse, ConnectionUserAndKey
from libcloud.compute.base import Node, NodeSize, NodeImage, NodeState, NodeDriver, NodeLocation
from libcloud.compute.types import Provider

[docs]class KamateraResponse(JsonResponse): """ Response class for KamateraDriver """
[docs] def parse_error(self): data = self.parse_body() if "message" in data: return data["message"] else: return json.dumps(data)
[docs]class KamateraConnection(ConnectionUserAndKey): """ Connection class for KamateraDriver """ host = "" responseCls = KamateraResponse
[docs] def add_default_headers(self, headers): """Adds headers that are needed for all requests""" headers["AuthClientId"] = self.user_id headers["AuthSecret"] = self.key headers["Accept"] = "application/json" headers["Content-Type"] = "application/json" return headers
[docs]class KamateraNodeDriver(NodeDriver): """ Kamatera node driver :keyword key: API Client ID, required for authentication :type key: ``str`` :keyword secret: API Secret, required for authentcaiont :type secret: ``str`` """ type = Provider.KAMATERA name = "Kamatera" website = "" connectionCls = KamateraConnection features = {"create_node": ["password", "generates_password", "ssh_key"]} EX_BILLINGCYCLE_HOURLY = "hourly" EX_BILLINGCYCLE_MONTHLY = "monthly"
[docs] def list_locations(self): """ List available locations for deployment :rtype: ``list`` of :class:`NodeLocation` """ response = self.connection.request("service/server?datacenter=1") return [ self.ex_get_location(datacenter["id"], datacenter["subCategory"], datacenter["name"]) for datacenter in response.object ]
[docs] def list_sizes(self, location): """ List predefined sizes for the given location. :param location: Location of the deployment. :type location: :class:`.NodeLocation` @inherits: :class:`NodeDriver.list_sizes` """ response = self.connection.request("service/server?sizes=1&datacenter=%s" % return [ self.ex_get_size( size["ramMB"], size["diskSizeGB"], size["cpuType"], size["cpuCores"], extraDiskSizesGB=[], monthlyTrafficPackage=size["monthlyTrafficPackage"], id=size["id"], ) for size in response.object ]
[docs] def list_images(self, location): """ List available disk images. :param location: Location of the deployment. Available disk images depend on location. :type location: :class:`.NodeLocation` :rtype: ``list`` of :class:`NodeImage` """ response = self.connection.request("service/server?images=1&datacenter=%s" % images = [] for image in response.object: extra = self._copy_dict(("datacenter", "os", "code", "osDiskSizeGB", "ramMBMin"), image) images.append(self.ex_get_image(image["name"], image["id"], extra)) return images
[docs] def create_node( self, name, size, image, location, auth=None, ex_networks=None, ex_dailybackup=False, ex_managed=False, ex_billingcycle=EX_BILLINGCYCLE_HOURLY, ex_poweronaftercreate=True, ex_wait=True, ): """ Creates a Kamatera node. If auth is not given then password will be generated. :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:`.NodeImage` :param location: Which data center to create a node in. (required) :type location: :class:`.NodeLocation` :param auth: Authentication information for the node (optional) :type auth: :class:`.NodeAuthSSHKey` or :class:`.NodeAuthPassword` :param ex_networks: Network configurations (optional) :type ex_networks: ``list`` of ``dict`` :param ex_dailybackup: Whether to create daily backups (optional) :type ex_dailybackup: ``bool`` :param ex_managed: Whether to provide managed support (optional) :type ex_managed: ``bool`` :param ex_billingcycle: billing cycle (hourly / monthly) (optional) :type ex_billingcycle: ``str`` :param ex_poweronaftercreate: power on after creation (optional) :type ex_poweronaftercreate: ``bool`` :param ex_wait: wait for server to be running (optional) :type ex_wait: ``bool`` :return: The newly created node. :rtype: :class:`.Node` """ password = None pubkey = None generate_password = False if isinstance(auth, basestring): password = auth else: auth_obj = self._get_and_check_auth(auth) if getattr(auth_obj, "generated", False): password = "__generate__" generate_password = True elif hasattr(auth_obj, "password"): password = auth_obj.password generate_password = False elif hasattr(auth_obj, "pubkey"): pubkey = auth_obj.pubkey if not ex_networks: ex_networks = [{"name": "wan", "ip": "auto"}] request_data = { "name": name, "password": password or "", "passwordValidate": password or "", "ssh-key": pubkey or "", "datacenter":, "image":, "cpu": "{}{}".format(size.extra["cpuCores"], size.extra["cpuType"]), "ram": size.ram, "disk": " ".join( ["size=%d" % disksize for disksize in [size.disk] + size.extra["extraDiskSizesGB"]] ), "dailybackup": "yes" if ex_dailybackup else "no", "managed": "yes" if ex_managed else "no", "network": " ".join( [ ",".join(["{}={}".format(k, v) for k, v in network.items()]) for network in ex_networks ] ), "quantity": 1, "billingcycle": ex_billingcycle, "monthlypackage": size.extra["monthlyTrafficPackage"] or "", "poweronaftercreate": "yes" if ex_poweronaftercreate else "no", } response = self.connection.request( "service/server", method="POST", data=json.dumps(request_data) ) if generate_password: command_ids = response.object["commandIds"] generated_password = response.object["password"] else: command_ids = response.object generated_password = None if len(command_ids) != 1: raise RuntimeError("invalid response") node = self.ex_get_node( name=name, size=size, image=image, location=location, dailybackup=ex_dailybackup, managed=ex_managed, billingcycle=ex_billingcycle, generated_password=generated_password, create_command_id=command_ids[0], poweronaftercreate=ex_poweronaftercreate, ) if ex_wait: if "create_command_id" not in node.extra or node.state != NodeState.UNKNOWN: raise ValueError("invalid node for updating create status") command = self.ex_wait_command(node.extra["create_command_id"]) node.extra["create_log"] = command.get("log") if node.extra.get("poweronaftercreate"): node.state = NodeState.RUNNING else: node.state = NodeState.STOPPED if command.get("completed"): node.created_at = datetime.datetime.strptime( command["completed"], "%Y-%m-%d %H:%M:%S" ) name_lines = [ line for line in node.extra["create_log"].split("\n") if line.startswith("Name: ") ] if len(name_lines) != 1: raise RuntimeError("Invalid node create log response") = name_lines[0].replace("Name: ", "") response = self.connection.request( "/service/server/info", method="POST", data=json.dumps({"name":}), ) self._update_node_from_server_info(node, response.object[0]) return node
[docs] def list_nodes(self, ex_name_regex=None, ex_full_details=False, ex_id=None): """ List nodes :param ex_name_regex: Regular expression to match node names if set returns full node details (optional) :type ex_name_regex: ``str`` :param ex_full_details: Whether to return full node details takes longer to complete (optional) :type ex_full_details: ``bool`` :return: List of node objects :rtype: ``list`` of :class:`Node` """ if ex_name_regex or ex_full_details or ex_id: request_data = {} if ex_id: request_data["id"] = ex_id else: if not ex_name_regex: ex_name_regex = ".*" request_data["name"] = ex_name_regex response = self.connection.request( "/service/server/info", method="POST", data=json.dumps(request_data) ) return [ self._update_node_from_server_info(self.ex_get_node(), server) for server in response.object ] else: response = self.connection.request("/service/servers") return [ self.ex_get_node( id=server["id"], name=server["name"], state=(NodeState.RUNNING if server["power"] == "on" else NodeState.STOPPED), location=self.ex_get_location(server["datacenter"]), ) for server in response.object ]
[docs] def reboot_node(self, node, ex_wait=True): """ Reboot the given node :param node: the node to reboot :type node: :class:`Node` :param ex_wait: wait for reboot to complete (optional) :type ex_wait: ``bool`` :rtype: ``bool`` """ return self.ex_node_operation(node, "reboot", ex_wait)
[docs] def destroy_node(self, node, ex_wait=True): """ Destroy the given node :param node: the node to destroy :type node: :class:`Node` :param ex_wait: wait for destroy to complete (optional) :type ex_wait: ``bool`` :rtype: ``bool`` """ return self.ex_node_operation(node, "terminate", ex_wait)
[docs] def stop_node(self, node, ex_wait=True): """ Stop the given node :param node: the node to stop :type node: :class:`Node` :param ex_wait: wait for stop to complete (optional) :type ex_wait: ``bool`` :rtype: ``bool`` """ return self.ex_node_operation(node, "poweroff", ex_wait)
[docs] def start_node(self, node, ex_wait=True): """ Start the given node :param node: the node to start :type node: :class:`Node` :param ex_wait: wait for start to complete (optional) :type ex_wait: ``bool`` :rtype: ``bool`` """ return self.ex_node_operation(node, "poweron", ex_wait)
[docs] def ex_node_operation(self, node, operation, wait=True): """ Run custom operations on the node :param node: the node to run operation on :type node: :class:`Node` :param operation: the operation to run :type operation: ``str`` :param ex_wait: wait for destroy to complete (optional) :type ex_wait: ``bool`` :rtype: ``bool`` """ if request_data = {"id":} elif request_data = {"name":} else: raise ValueError("Invalid node for %s node operation: " "missing id / name" % operation) if operation == "terminate": request_data["force"] = True command_id = self.connection.request( "/service/server/%s" % operation, method="POST", data=json.dumps(request_data), ).object[0] if wait: self.ex_wait_command(command_id) else: node.extra["%s_command_id" % operation] = command_id return True
[docs] def ex_get_location(self, id, name=None, country=None): """ Get a NodeLocation object to use for other methods :param id: Location ID - uppercase letters code (required) :type id: ``str`` :param name: Location Name (optional) :type name: ``str`` :param name: Location country (optional) :type name: ``str`` :rtype: :class:`.NodeLocation` """ return NodeLocation(id=id, name=name, country=country, driver=self)
[docs] def ex_get_size( self, ramMB, diskSizeGB, cpuType, cpuCores, extraDiskSizesGB=None, monthlyTrafficPackage=None, id=None, name=None, ): """ Get a NodeSize object to use for other methods :param ramMB: Amount of RAM to allocate in MB (required) :type ramMB: ``int`` :param diskSizeGB: disk size GB for primary hard disk (required) :type diskSizeGB: ``int`` :param cpuType: CPU type ID (single uppercase letter), see ex_list_capabilities (required) :type cpuType: ``str`` :param cpuCores: Number of CPU cores to allocate (required) :type cpuCores: ``int`` :param extraDiskSizesGB: additional disk sizes in GB (optional) :type extraDiskSizesGB: ``list`` of :int: :param monthlyTrafficPackage: ID of monthly traffic package see ex_list_capabilities (optional) :type monthlyTrafficPackage: ``str`` :param id: Size ID (optional) :type id: ``str`` :param name: Size Name (optional) :type name: ``str`` :rtype: :class:`.NodeLocation` """ if not id: id = str(cpuCores) + cpuType id += "-" + str(ramMB) + "MB-" + str(diskSizeGB) + "GB" if monthlyTrafficPackage: id += "-" + monthlyTrafficPackage if not name: name = id return NodeSize( id=id, name=name, ram=ramMB, disk=diskSizeGB, bandwidth=0, price=0, driver=self.connection.driver, extra={ "cpuType": cpuType, "cpuCores": cpuCores, "monthlyTrafficPackage": monthlyTrafficPackage, "extraDiskSizesGB": extraDiskSizesGB or [], }, )
[docs] def ex_get_image(self, name=None, id=None, extra=None): if not id and not name: raise ValueError("either id or name are required for NodeImage") return NodeImage(id=id or name, name=name or "", driver=self, extra=extra or {})
[docs] def ex_list_capabilities(self, location): """ List capabilities for given location. :param location: Location of the deployment. :type location: :class:`.NodeLocation` :return: ``dict`` """ return self.connection.request( "service/server?capabilities=1&" "datacenter=%s" % ).object
[docs] def ex_wait_command(self, command_id, timeout_seconds=600, poll_interval_seconds=2): """ Wait for command to complete and return the command status details :param command_id: Command ID to wait for. (required) :type command_id: ``int`` :param timeout_seconds: Max seconds to wait for command. (optional) :type timeout_seconds: ``int`` :param poll_interval_seconds: Poll interval in seconds (optional) :type poll_interval_seconds: ``int`` :return: ``dict`` """ start_time = time.sleep(poll_interval_seconds) while True: max_time = start_time + datetime.timedelta(seconds=timeout_seconds) if max_time < raise TimeoutError( "Timeout waiting for command " "(timeout_seconds=%s, command_id=%s)" % (str(timeout_seconds), str(command_id)) ) time.sleep(poll_interval_seconds) command = self.ex_get_command_status(command_id) status = command.get("status") if status == "complete": return command elif status == "error": raise RuntimeError("Command failed: " + command.get("log"))
[docs] def ex_get_command_status(self, command_id): """ Get Kamatera command status details :param command_id: Command ID to get details for. (required) :type command_id: ``int`` :return: ``dict`` """ response = self.connection.request("/service/queue?id=" + str(command_id)) if len(response.object) != 1: raise RuntimeError("invalid response") return response.object[0]
[docs] def ex_get_node( self, id=None, name=None, state=NodeState.UNKNOWN, public_ips=None, private_ips=None, size=None, image=None, created_at=None, location=None, dailybackup=None, managed=None, billingcycle=None, generated_password=None, create_command_id=None, poweronaftercreate=None, ): """ Get a Kamatera node object. :param id: Node ID (optional) :type id: ``str`` :param name: Node name (optional) :type name: ``str`` :param state: Node state (optional) :type state: :class:`libcloud.compute.types.NodeState` :param public_ips: Node public IPS. (optional) :type public_ips: ``list`` of :str: :param private_ips: Node private IPS. (optional) :type private_ips: ``list`` of :str: :param size: node size. (optional) :type size: :class:`.NodeSize` :param image: Node OS Image. (optional) :type image: :class:`.NodeImage` :param created_at: Node creation time. (optional) :type created_at: ``datetime.datetime`` :param location: Node datacenter. (optional) :type location: :class:`.NodeLocation` :param dailybackup: create daily backups for the node (optional) :type dailybackup: ``bool`` :param managed: provide managed support for the node (optional) :type managed: ``bool`` :param billingcycle: billing cycle (hourly / monthly) (optional) :type billingcycle: ``str`` :param generated_password: server generated password (optional) :type generated_password: ``str`` :param create_command_id: creation task command ID (optional) :type create_command_id: ``int`` :param poweronaftercreate: power on the node after create (optional) :type poweronaftercreate: ``bool`` :return: The node. :rtype: :class:`.Node` """ extra = {} if location: extra["location"] = location if dailybackup is not None: extra["dailybackup"] = dailybackup if managed is not None: extra["managed"] = managed if billingcycle is not None: extra["billingcycle"] = billingcycle if generated_password is not None: extra["generated_password"] = generated_password if create_command_id is not None: extra["create_command_id"] = create_command_id if poweronaftercreate is not None: extra["poweronaftercreate"] = poweronaftercreate return Node( id=id, name=name, state=state, public_ips=public_ips, private_ips=private_ips, driver=self, size=size, image=image, created_at=created_at, extra=extra, )
def _copy_dict(self, keys, d): extra = {} for key in keys: extra[key] = d[key] return extra def _update_node_from_server_info(self, node, server): = server["id"] = server["name"] if server["power"] == "on": node.state = NodeState.RUNNING else: node.state = NodeState.STOPPED for network in server.get("networks", []): if network.get("network").startswith("wan-"): node.public_ips += network.get("ips", []) else: node.private_ips += network.get("ips", []) billing = server.get("billing", node.extra.get("billingcycle")).lower() if billing == self.EX_BILLINGCYCLE_HOURLY: node.extra["billingcycle"] = self.EX_BILLINGCYCLE_HOURLY node.extra["priceOn"] = server.get("priceHourlyOn") node.extra["priceOff"] = server.get("priceHourlyOff") else: node.extra["billingcycle"] = self.EX_BILLINGCYCLE_MONTHLY node.extra["priceOn"] = server.get("priceMonthlyOn") node.extra["priceOff"] = server.get("priceMonthlyOn") node.extra["location"] = self.ex_get_location(server["datacenter"]) node.extra["dailybackup"] = server.get("backup") == "1" node.extra["managed"] = server.get("managed") == "1" return node