Source code for libcloud.compute.drivers.elasticstack

# 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.

Base driver for the providers based on the ElasticStack platform -

import re
import time
import base64

from libcloud.utils.py3 import httplib
from libcloud.utils.py3 import b

    import simplejson as json
except ImportError:
    import json

from libcloud.common.base import ConnectionUserAndKey, JsonResponse
from libcloud.common.types import InvalidCredsError
from libcloud.compute.types import NodeState
from libcloud.compute.base import NodeDriver, NodeSize, Node
from libcloud.compute.base import NodeImage
from libcloud.compute.deployment import ScriptDeployment, SSHKeyDeployment
from libcloud.compute.deployment import MultiStepDeployment

    "active": NodeState.RUNNING,
    "dead": NodeState.TERMINATED,
    "dumped": NodeState.TERMINATED,

# Default timeout (in seconds) for the drive imaging process

# ElasticStack doesn't specify special instance types, so I just specified
# some plans based on the other provider offerings.
# Basically for CPU any value between 500Mhz and 20000Mhz should work,
# 256MB to 8192MB for ram and 1GB to 2TB for disk.
    "small": {
        "id": "small",
        "name": "Small instance",
        "cpu": 2000,
        "memory": 1700,
        "disk": 160,
        "bandwidth": None,
    "medium": {
        "id": "medium",
        "name": "Medium instance",
        "cpu": 3000,
        "memory": 4096,
        "disk": 500,
        "bandwidth": None,
    "large": {
        "id": "large",
        "name": "Large instance",
        "cpu": 4000,
        "memory": 7680,
        "disk": 850,
        "bandwidth": None,
    "extra-large": {
        "id": "extra-large",
        "name": "Extra Large instance",
        "cpu": 8000,
        "memory": 8192,
        "disk": 1690,
        "bandwidth": None,
    "high-cpu-medium": {
        "id": "high-cpu-medium",
        "name": "High-CPU Medium instance",
        "cpu": 5000,
        "memory": 1700,
        "disk": 350,
        "bandwidth": None,
    "high-cpu-extra-large": {
        "id": "high-cpu-extra-large",
        "name": "High-CPU Extra Large instance",
        "cpu": 20000,
        "memory": 7168,
        "disk": 1690,
        "bandwidth": None,

[docs]class ElasticStackException(Exception): def __str__(self): # pylint: disable=unsubscriptable-object return self.args[0] def __repr__(self): # pylint: disable=unsubscriptable-object return "<ElasticStackException '%s'>" % (self.args[0])
[docs]class ElasticStackResponse(JsonResponse):
[docs] def success(self): if self.status == 401: raise InvalidCredsError() return 200 <= self.status <= 299
[docs] def parse_error(self): error_header = self.headers.get("x-elastic-error", "") return "X-Elastic-Error: %s (%s)" % (error_header, self.body.strip())
[docs]class ElasticStackNodeSize(NodeSize): def __init__(self, id, name, cpu, ram, disk, bandwidth, price, driver): = id = name self.cpu = cpu self.ram = ram self.disk = disk self.bandwidth = bandwidth self.price = price self.driver = driver def __repr__(self): return ( "<NodeSize: id=%s, name=%s, cpu=%s, ram=%s " "disk=%s bandwidth=%s price=%s driver=%s ...>" ) % (,, self.cpu, self.ram, self.disk, self.bandwidth, self.price,, )
[docs]class ElasticStackBaseConnection(ConnectionUserAndKey): """ Base connection class for the ElasticStack driver """ host = None responseCls = ElasticStackResponse
[docs] def add_default_headers(self, headers): headers["Accept"] = "application/json" headers["Content-Type"] = "application/json" headers["Authorization"] = "Basic %s" % ( base64.b64encode(b("%s:%s" % (self.user_id, self.key))) ).decode("utf-8") return headers
[docs]class ElasticStackBaseNodeDriver(NodeDriver): website = "" connectionCls = ElasticStackBaseConnection features = {"create_node": ["generates_password"]} # Dynamically populated by sub-classes _standard_drives = {}
[docs] def reboot_node(self, node): # Reboots the node response = self.connection.request( action="/servers/%s/reset" % (, method="POST" ) return response.status == 204
[docs] def destroy_node(self, node): # Kills the server immediately response = self.connection.request( action="/servers/%s/destroy" % (, method="POST" ) return response.status == 204
[docs] def list_images(self, location=None): # Returns a list of available pre-installed system drive images images = [] for key, value in self._standard_drives.items(): image = NodeImage( id=value["uuid"], name=value["description"], driver=self.connection.driver, extra={"size_gunzipped": value["size_gunzipped"]}, ) images.append(image) return images
[docs] def list_sizes(self, location=None): sizes = [] for key, value in INSTANCE_TYPES.items(): size = ElasticStackNodeSize( id=value["id"], name=value["name"], cpu=value["cpu"], ram=value["memory"], disk=value["disk"], bandwidth=value["bandwidth"], price=self._get_size_price(size_id=value["id"]), driver=self.connection.driver, ) sizes.append(size) return sizes
[docs] def list_nodes(self): # Returns a list of active (running) nodes response = self.connection.request(action="/servers/info").object nodes = [] for data in response: node = self._to_node(data) nodes.append(node) return nodes
[docs] def create_node( self, name, size, image, smp="auto", nic_model="e1000", vnc_password=None, drive_type="hdd", ): """Creates an ElasticStack instance @inherits: :class:`NodeDriver.create_node` :keyword name: String with a name for this new node (required) :type name: ``str`` :keyword smp: Number of virtual processors or None to calculate based on the cpu speed :type smp: ``int`` :keyword nic_model: e1000, rtl8139 or virtio (if not specified, e1000 is used) :type nic_model: ``str`` :keyword vnc_password: If set, the same password is also used for SSH access with user toor, otherwise VNC access is disabled and no SSH login is possible. :type vnc_password: ``str`` """ ssh_password = vnc_password if nic_model not in ("e1000", "rtl8139", "virtio"): raise ElasticStackException("Invalid NIC model specified") # check that drive size is not smaller than pre installed image size # First we create a drive with the specified size drive_data = {} drive_data.update({"name": name, "size": "%sG" % (size.disk)}) response = self.connection.request( action="/drives/create", data=json.dumps(drive_data), method="POST" ).object if not response: raise ElasticStackException("Drive creation failed") drive_uuid = response["drive"] # Then we image the selected pre-installed system drive onto it response = self.connection.request( action="/drives/%s/image/%s/gunzip" % (drive_uuid,, method="POST" ) if response.status not in (200, 204): raise ElasticStackException("Drive imaging failed") # We wait until the drive is imaged and then boot up the node # (in most cases, the imaging process shouldn't take longer # than a few minutes) response = self.connection.request( action="/drives/%s/info" % (drive_uuid) ).object imaging_start = time.time() while "imaging" in response: response = self.connection.request( action="/drives/%s/info" % (drive_uuid) ).object elapsed_time = time.time() - imaging_start if "imaging" in response and elapsed_time >= IMAGING_TIMEOUT: raise ElasticStackException("Drive imaging timed out") time.sleep(1) node_data = {} node_data.update( { "name": name, "cpu": size.cpu, "mem": size.ram, "ide:0:0": drive_uuid, "boot": "ide:0:0", "smp": smp, } ) node_data.update({"nic:0:model": nic_model, "nic:0:dhcp": "auto"}) if vnc_password: node_data.update({"vnc": "auto", "vnc:password": vnc_password}) response = self.connection.request( action="/servers/create", data=json.dumps(node_data), method="POST" ).object if isinstance(response, list): nodes = [self._to_node(node, ssh_password) for node in response] else: nodes = self._to_node(response, ssh_password) return nodes
# Extension methods
[docs] def ex_set_node_configuration(self, node, **kwargs): """ Changes the configuration of the running server :param node: Node which should be used :type node: :class:`Node` :param kwargs: keyword arguments :type kwargs: ``dict`` :rtype: ``bool`` """ valid_keys = ( "^name$", "^parent$", "^cpu$", "^smp$", "^mem$", "^boot$", "^nic:0:model$", "^nic:0:dhcp", "^nic:1:model$", "^nic:1:vlan$", "^nic:1:mac$", "^vnc:ip$", "^vnc:password$", "^vnc:tls", "^ide:[0-1]:[0-1](:media)?$", "^scsi:0:[0-7](:media)?$", "^block:[0-7](:media)?$", ) invalid_keys = [] keys = list(kwargs.keys()) for key in keys: matches = False for regex in valid_keys: if re.match(regex, key): matches = True break if not matches: invalid_keys.append(key) if invalid_keys: raise ElasticStackException( "Invalid configuration key specified: %s" % (",".join(invalid_keys)) ) response = self.connection.request( action="/servers/%s/set" % (, data=json.dumps(kwargs), method="POST" ) return response.status == httplib.OK and response.body != ""
[docs] def deploy_node(self, **kwargs): """ Create a new node, and start deployment. @inherits: :class:`NodeDriver.deploy_node` :keyword enable_root: If true, root password will be set to vnc_password (this will enable SSH access) and default 'toor' account will be deleted. :type enable_root: ``bool`` """ image = kwargs["image"] vnc_password = kwargs.get("vnc_password", None) enable_root = kwargs.get("enable_root", False) if not vnc_password: raise ValueError( "You need to provide vnc_password argument " "if you want to use deployment" ) if ( image in self._standard_drives and not self._standard_drives[image]["supports_deployment"] ): raise ValueError("Image %s does not support deployment" % ( if enable_root: script = ( "unset HISTFILE;" "echo root:%s | chpasswd;" "sed -i '/^toor.*$/d' /etc/passwd /etc/shadow;" "history -c" ) % vnc_password root_enable_script = ScriptDeployment(script=script, delete=True) deploy = kwargs.get("deploy", None) if deploy: if isinstance(deploy, ScriptDeployment) or isinstance( deploy, SSHKeyDeployment ): deployment = MultiStepDeployment([deploy, root_enable_script]) elif isinstance(deploy, MultiStepDeployment): deployment = deploy deployment.add(root_enable_script) else: deployment = root_enable_script kwargs["deploy"] = deployment if not kwargs.get("ssh_username", None): kwargs["ssh_username"] = "toor" return super(ElasticStackBaseNodeDriver, self).deploy_node(**kwargs)
[docs] def ex_shutdown_node(self, node): """ Sends the ACPI power-down event :param node: Node which should be used :type node: :class:`Node` :rtype: ``bool`` """ response = self.connection.request( action="/servers/%s/shutdown" % (, method="POST" ) return response.status == 204
[docs] def ex_destroy_drive(self, drive_uuid): """ Deletes a drive :param drive_uuid: Drive uuid which should be used :type drive_uuid: ``str`` :rtype: ``bool`` """ response = self.connection.request( action="/drives/%s/destroy" % (drive_uuid), method="POST" ) return response.status == 204
# Helper methods def _to_node(self, data, ssh_password=None): try: state = NODE_STATE_MAP[data["status"]] except KeyError: state = NodeState.UNKNOWN if "nic:0:dhcp:ip" in data: if isinstance(data["nic:0:dhcp:ip"], list): public_ip = data["nic:0:dhcp:ip"] else: public_ip = [data["nic:0:dhcp:ip"]] else: public_ip = [] extra = {"cpu": data["cpu"], "mem": data["mem"]} if "started" in data: extra["started"] = data["started"] if "smp" in data: extra["smp"] = data["smp"] if "vnc:ip" in data: extra["vnc:ip"] = data["vnc:ip"] if "vnc:password" in data: extra["vnc:password"] = data["vnc:password"] boot_device = data["boot"] if isinstance(boot_device, list): for device in boot_device: extra[device] = data[device] else: extra[boot_device] = data[boot_device] if ssh_password: extra.update({"password": ssh_password}) node = Node( id=data["server"], name=data["name"], state=state, public_ips=public_ip, private_ips=None, driver=self.connection.driver, extra=extra, ) return node