Source code for libcloud.compute.drivers.onapp

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

import json

from libcloud.utils.py3 import httplib
from libcloud.common.onapp import OnAppConnection
from libcloud.compute.base import Node, KeyPair, NodeImage, NodeDriver
from libcloud.utils.networking import is_private_subnet
from libcloud.compute.providers import Provider

__all__ = ["OnAppNodeDriver"]

"""
Define the extra dictionary for specific resources
"""
RESOURCE_EXTRA_ATTRIBUTES_MAP = {
    "node": {
        "add_to_marketplace": {
            "key_name": "add_to_marketplace",
            "transform_func": bool,
        },
        "admin_note": {"key_name": "admin_note", "transform_func": str},
        "allow_resize_without_reboot": {
            "key_name": "allow_resize_without_reboot",
            "transform_func": bool,
        },
        "allowed_hot_migrate": {
            "key_name": "allowed_hot_migrate",
            "transform_func": bool,
        },
        "allowed_swap": {"key_name": "allowed_swap", "transform_func": bool},
        "booted": {"key_name": "booted", "transform_func": bool},
        "built": {"key_name": "built", "transform_func": bool},
        "cpu_priority": {"key_name": "cpu_priority", "transform_func": int},
        "cpu_shares": {"key_name": "cpu_shares", "transform_func": int},
        "cpu_sockets": {"key_name": "cpu_sockets", "transform_func": int},
        "cpu_threads": {"key_name": "cpu_threads", "transform_func": int},
        "cpu_units": {"key_name": "cpu_units", "transform_func": int},
        "cpus": {"key_name": "cpus", "transform_func": int},
        "created_at": {"key_name": "created_at", "transform_func": str},
        "customer_network_id": {
            "key_name": "customer_network_id",
            "transform_func": str,
        },
        "deleted_at": {"key_name": "deleted_at", "transform_func": str},
        "edge_server_type": {"key_name": "edge_server_type", "transform_func": str},
        "enable_autoscale": {"key_name": "enable_autoscale", "transform_func": bool},
        "enable_monitis": {"key_name": "enable_monitis", "transform_func": bool},
        "firewall_notrack": {"key_name": "firewall_notrack", "transform_func": bool},
        "hostname": {"key_name": "hostname", "transform_func": str},
        "hypervisor_id": {"key_name": "hypervisor_id", "transform_func": int},
        "id": {"key_name": "id", "transform_func": int},
        "initial_root_password": {
            "key_name": "initial_root_password",
            "transform_func": str,
        },
        "initial_root_password_encrypted": {
            "key_name": "initial_root_password_encrypted",
            "transform_func": bool,
        },
        "local_remote_access_ip_address": {
            "key_name": "local_remote_access_ip_address",
            "transform_func": str,
        },
        "local_remote_access_port": {
            "key_name": "local_remote_access_port",
            "transform_func": int,
        },
        "locked": {"key_name": "locked", "transform_func": bool},
        "memory": {"key_name": "memory", "transform_func": int},
        "min_disk_size": {"key_name": "min_disk_size", "transform_func": int},
        "monthly_bandwidth_used": {
            "key_name": "monthly_bandwidth_used",
            "transform_func": int,
        },
        "note": {"key_name": "note", "transform_func": str},
        "operating_system": {"key_name": "operating_system", "transform_func": str},
        "operating_system_distro": {
            "key_name": "operating_system_distro",
            "transform_func": str,
        },
        "preferred_hvs": {"key_name": "preferred_hvs", "transform_func": list},
        "price_per_hour": {"key_name": "price_per_hour", "transform_func": float},
        "price_per_hour_powered_off": {
            "key_name": "price_per_hour_powered_off",
            "transform_func": float,
        },
        "recovery_mode": {"key_name": "recovery_mode", "transform_func": bool},
        "remote_access_password": {
            "key_name": "remote_access_password",
            "transform_func": str,
        },
        "service_password": {"key_name": "service_password", "transform_func": str},
        "state": {"key_name": "state", "transform_func": str},
        "storage_server_type": {
            "key_name": "storage_server_type",
            "transform_func": str,
        },
        "strict_virtual_machine_id": {
            "key_name": "strict_virtual_machine_id",
            "transform_func": str,
        },
        "support_incremental_backups": {
            "key_name": "support_incremental_backups",
            "transform_func": bool,
        },
        "suspended": {"key_name": "suspended", "transform_func": bool},
        "template_id": {"key_name": "template_id", "transform_func": int},
        "template_label": {"key_name": "template_label", "transform_func": str},
        "total_disk_size": {"key_name": "total_disk_size", "transform_func": int},
        "updated_at": {"key_name": "updated_at", "transform_func": str},
        "user_id": {"key_name": "user_id", "transform_func": int},
        "vip": {"key_name": "vip", "transform_func": bool},
        "xen_id": {"key_name": "xen_id", "transform_func": int},
    }
}


[docs]class OnAppNodeDriver(NodeDriver): """ Base OnApp node driver. """ connectionCls = OnAppConnection type = Provider.ONAPP name = "OnApp" website = "http://onapp.com/"
[docs] def create_node( self, name, ex_memory, ex_cpus, ex_cpu_shares, ex_hostname, ex_template_id, ex_primary_disk_size, ex_swap_disk_size, ex_required_virtual_machine_build=1, ex_required_ip_address_assignment=1, **kwargs, ): """ Add a VS :param kwargs: All keyword arguments to create a VS :type kwargs: ``dict`` :rtype: :class:`OnAppNode` """ server_params = dict( label=name, memory=ex_memory, cpus=ex_cpus, cpu_shares=ex_cpu_shares, hostname=ex_hostname, template_id=ex_template_id, primary_disk_size=ex_primary_disk_size, swap_disk_size=ex_swap_disk_size, required_virtual_machine_build=ex_required_virtual_machine_build, required_ip_address_assignment=ex_required_ip_address_assignment, rate_limit=kwargs.get("rate_limit"), ) server_params.update(OnAppNodeDriver._create_args_to_params(**kwargs)) data = json.dumps({"virtual_machine": server_params}) response = self.connection.request( "/virtual_machines.json", data=data, headers={"Content-type": "application/json"}, method="POST", ) return self._to_node(response.object["virtual_machine"])
[docs] def destroy_node(self, node, ex_convert_last_backup=0, ex_destroy_all_backups=0): """ Delete a VS :param node: OnApp node :type node: :class: `OnAppNode` :param convert_last_backup: set 1 to convert the last VS's backup to template, otherwise set 0 :type convert_last_backup: ``int`` :param destroy_all_backups: set 1 to destroy all existing backups of this VS, otherwise set 0 :type destroy_all_backups: ``int`` """ server_params = { "convert_last_backup": ex_convert_last_backup, "destroy_all_backups": ex_destroy_all_backups, } action = "/virtual_machines/{identifier}.json".format(identifier=node.id) self.connection.request(action, params=server_params, method="DELETE") return True
[docs] def list_nodes(self): """ List all VS :rtype: ``list`` of :class:`OnAppNode` """ response = self.connection.request("/virtual_machines.json") nodes = [] for vm in response.object: nodes.append(self._to_node(vm["virtual_machine"])) return nodes
[docs] def list_images(self): """ List all images :rtype: ``list`` of :class:`NodeImage` """ response = self.connection.request("/templates.json") templates = [] for template in response.object: templates.append(self._to_image(template["image_template"])) return templates
[docs] def list_key_pairs(self): """ List all the available key pair objects. :rtype: ``list`` of :class:`.KeyPair` objects """ user_id = self.connection.request("/profile.json").object["user"]["id"] response = self.connection.request("/users/%s/ssh_keys.json" % user_id) ssh_keys = [] for ssh_key in response.object: ssh_keys.append(self._to_key_pair(ssh_key["ssh_key"])) return ssh_keys
[docs] def get_key_pair(self, name): """ Retrieve a single key pair. :param name: ID of the key pair to retrieve. :type name: ``str`` :rtype: :class:`.KeyPair` object """ user_id = self.connection.request("/profile.json").object["user"]["id"] response = self.connection.request("/users/{}/ssh_keys/{}.json".format(user_id, name)) return self._to_key_pair(response.object["ssh_key"])
[docs] def import_key_pair_from_string(self, name, key_material): """ Import a new public key from string. :param name: Key pair name (unused). :type name: ``str`` :param key_material: Public key material. :type key_material: ``str`` :rtype: :class:`.KeyPair` object """ data = json.dumps({"key": key_material}) user_id = self.connection.request("/profile.json").object["user"]["id"] response = self.connection.request( "/users/%s/ssh_keys.json" % user_id, data=data, headers={"Content-type": "application/json"}, method="POST", ) return self._to_key_pair(response.object["ssh_key"])
[docs] def delete_key_pair(self, key): """ Delete an existing key pair. :param key_pair: Key pair object. :type key_pair: :class:`.KeyPair` :return: True on success :rtype: ``bool`` """ key_id = key.name response = self.connection.request("/settings/ssh_keys/%s.json" % key_id, method="DELETE") return response.status == httplib.NO_CONTENT
# # Helper methods # def _to_key_pair(self, data): extra = {"created_at": data["created_at"], "updated_at": data["updated_at"]} return KeyPair( name=data["id"], fingerprint=None, public_key=data["key"], private_key=None, driver=self, extra=extra, ) def _to_image(self, template): extra = { "distribution": template["operating_system_distro"], "operating_system": template["operating_system"], "operating_system_arch": template["operating_system_arch"], "allow_resize_without_reboot": template["allow_resize_without_reboot"], "allowed_hot_migrate": template["allowed_hot_migrate"], "allowed_swap": template["allowed_swap"], "min_disk_size": template["min_disk_size"], "min_memory_size": template["min_memory_size"], "created_at": template["created_at"], } return NodeImage(id=template["id"], name=template["label"], driver=self, extra=extra) def _to_node(self, data): identifier = data["identifier"] name = data["label"] private_ips = [] public_ips = [] for ip in data["ip_addresses"]: address = ip["ip_address"]["address"] if is_private_subnet(address): private_ips.append(address) else: public_ips.append(address) extra = OnAppNodeDriver._get_extra_dict(data, RESOURCE_EXTRA_ATTRIBUTES_MAP["node"]) return Node(identifier, name, extra["state"], public_ips, private_ips, self, extra=extra) @staticmethod def _get_extra_dict(response, mapping): """ Extract attributes from the element based on rules provided in the mapping dictionary. :param response: The JSON response to parse the values from. :type response: ``dict`` :param mapping: Dictionary with the extra layout :type mapping: ``dict`` :rtype: ``dict`` """ extra = {} for attribute, values in mapping.items(): transform_func = values["transform_func"] value = response.get(values["key_name"]) extra[attribute] = transform_func(value) if value else None return extra @staticmethod def _create_args_to_params(**kwargs): """ Extract server params from keyword args to create a VS :param kwargs: keyword args :return: ``dict`` """ params = [ "ex_cpu_sockets", "ex_cpu_threads", "ex_enable_autoscale", "ex_data_store_group_primary_id", "ex_data_store_group_swap_id", "ex_hypervisor_group_id", "ex_hypervisor_id", "ex_initial_root_password", "ex_note", "ex_primary_disk_min_iops", "ex_primary_network_id", "ex_primary_network_group_id", "ex_recipe_ids", "ex_required_automatic_backup", "ex_required_virtual_machine_startup", "ex_required_virtual_machine_startup", "ex_selected_ip_address_id", "ex_swap_disk_min_iops", "ex_type_of_format", "ex_custom_recipe_variables", "ex_licensing_key", "ex_licensing_server_id", "ex_licensing_type", ] server_params = {} for p in params: value = kwargs.get(p) if value: server_params[p[3:]] = value return server_params