FM / drivers

/opt/imh-python/lib/python3.9/site-packages/libcloud/compute/drivers/

/opt/imh-python/lib/python3.9/site-packages/libcloud/compute/drivers

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
abiquo.py	31529	0644	edit dl rm
auroracompute.py	2040	0644	edit dl rm
azure.py	113227	0644	edit dl rm
azure_arm.py	83132	0644	edit dl rm
bluebox.py	7426	0644	edit dl rm
brightbox.py	10859	0644	edit dl rm
bsnl.py	1958	0644	edit dl rm
cloudscale.py	8844	0644	edit dl rm
cloudsigma.py	68769	0644	edit dl rm
cloudstack.py	163834	0644	edit dl rm
cloudwatt.py	5094	0644	edit dl rm
digitalocean.py	27064	0644	edit dl rm
dimensiondata.py	189557	0644	edit dl rm
dummy.py	11074	0644	edit dl rm
ec2.py	219386	0644	edit dl rm
ecp.py	11723	0644	edit dl rm
ecs.py	63818	0644	edit dl rm
elastichosts.py	7441	0644	edit dl rm
elasticstack.py	16348	0644	edit dl rm
exoscale.py	1159	0644	edit dl rm
gandi.py	26305	0644	edit dl rm
gce.py	389086	0644	edit dl rm
gig_g8.py	22013	0644	edit dl rm
gogrid.py	15250	0644	edit dl rm
gridscale.py	35381	0644	edit dl rm
gridspot.py	4243	0644	edit dl rm
hostvirtual.py	14427	0644	edit dl rm
ikoula.py	1172	0644	edit dl rm
indosat.py	1997	0644	edit dl rm
internetsolutions.py	2050	0644	edit dl rm
joyent.py	8213	0644	edit dl rm
kamatera.py	23481	0644	edit dl rm
kili.py	3199	0644	edit dl rm
ktucloud.py	3595	0644	edit dl rm
kubevirt.py	40678	0644	edit dl rm
libvirt_driver.py	14671	0644	edit dl rm
linode.py	26646	0644	edit dl rm
maxihost.py	8419	0644	edit dl rm
medone.py	1984	0644	edit dl rm
nephoscale.py	17690	0644	edit dl rm
ntta.py	2011	0644	edit dl rm
nttcis.py	222933	0644	edit dl rm
onapp.py	16503	0644	edit dl rm
oneandone.py	57758	0644	edit dl rm
opennebula.py	43343	0644	edit dl rm
openstack.py	144008	0644	edit dl rm
ovh.py	18845	0644	edit dl rm
packet.py	33684	0644	edit dl rm
profitbricks.py	120806	0644	edit dl rm
rackspace.py	9442	0644	edit dl rm
rimuhosting.py	12292	0644	edit dl rm
scaleway.py	24231	0644	edit dl rm
serverlove.py	2934	0644	edit dl rm
skalicloud.py	2917	0644	edit dl rm
softlayer.py	17921	0644	edit dl rm
upcloud.py	11156	0644	edit dl rm
vcl.py	8843	0644	edit dl rm
vcloud.py	94722	0644	edit dl rm
voxel.py	10927	0644	edit dl rm
vpsnet.py	6721	0644	edit dl rm
vsphere.py	18407	0644	edit dl rm
vultr.py	13328	0644	edit dl rm
__init__.py	1207	0644	edit dl rm

Edit: /opt/imh-python/lib/python3.9/site-packages/libcloud/compute/drivers/oneandone.py (57758B)

# 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.
"""
1&1 Cloud Server Compute driver
"""
import json

from libcloud.compute.providers import Provider
from libcloud.common.base import JsonResponse, ConnectionKey
from libcloud.compute.base import NodeSize, NodeImage, NodeLocation, \
    Node, NodeAuthPassword, NodeAuthSSHKey
from libcloud.common.types import InvalidCredsError
from libcloud.compute.types import NodeState
from libcloud.utils.py3 import httplib
from libcloud.compute.base import NodeDriver

from time import sleep

API_HOST = 'cloudpanel-api.1and1.com'
API_VERSION = '/v1/'

__all__ = [
    'API_HOST',
    'API_VERSION',
    'OneAndOneResponse',
    'OneAndOneConnection',
    'OneAndOneNodeDriver'
]

class OneAndOneResponse(JsonResponse):
    """
    OneAndOne response parsing.
    """
    valid_response_codes = [httplib.OK, httplib.CREATED, httplib.ACCEPTED]

def parse_error(self):

if self.status == httplib.UNAUTHORIZED:
            body = self.parse_body()
            raise InvalidCredsError(body['message'])
        else:
            body = self.parse_body()
            if 'message' in body:
                error = '%s (code: %s)' % (body['message'], self.status)
            else:
                error = body
            return error

def success(self):
        return self.status in self.valid_response_codes

class OneAndOneConnection(ConnectionKey):
    """
    Connection class for the 1&1 driver
    """

host = API_HOST
    api_prefix = API_VERSION
    responseCls = OneAndOneResponse

def encode_data(self, data):
        return json.dumps(data)

def add_default_headers(self, headers):
        """
        Add headers that are necessary for every request

This method adds ``token`` and ``Content-Type`` to the request.
        """
        headers['X-Token'] = self.key
        headers['Content-Type'] = 'application/json'
        return headers

def request(self, action, params=None, data=None, headers=None,
                method='GET', raw=False):
        """
        Some requests will use the href attribute directly.
        If this is not the case, then we should formulate the
        url based on the action specified.
        If we are using a full url, we need to remove the
        host and protocol components.
        """
        action = self.api_prefix + action.lstrip('/')

return super(OneAndOneConnection, self). \
            request(action=action,
                    params=params,
                    data=data,
                    headers=headers,
                    method=method,
                    raw=raw)

class OneAndOneNodeDriver(NodeDriver):
    """
      Base OneAndOne node driver.
    """
    connectionCls = OneAndOneConnection
    name = '1and1'
    website = 'http://www.1and1.com'
    type = Provider.ONEANDONE

NODE_STATE_MAP = {
        'POWERING_ON': NodeState.STARTING,
        'POWERING_OFF': NodeState.PENDING,
        'POWERED_OFF': NodeState.STOPPING,
        'POWERED_ON': NodeState.RUNNING,
        'REBOOTING': NodeState.REBOOTING,
        'CONFIGURING': NodeState.RECONFIGURING,
        'REMOVING': NodeState.UNKNOWN,
        'DEPLOYING': NodeState.STARTING,
    }

"""
    Core Functions
    """

def list_sizes(self):
        """
        Lists all sizes

:return: A list of all configurable node sizes.
        :rtype: ``list`` of :class:`NodeSize`
        """
        sizes = []

fixed_instances = self._list_fixed_instances()
        for value in fixed_instances:
            node_size = self._to_node_size(value)
            sizes.append(node_size)

return sizes

def list_locations(self):
        """
        Lists all locations

:return: ``list`` of :class:`NodeLocation`
        :rtype: ``list``
        """
        datacenters = self.ex_list_datacenters()
        locations = []
        for values in datacenters:
            node_size = self._to_location(values)
            locations.append(node_size)

return locations

def list_images(self, image_type=None):
        """
        :return: ``list`` of :class: `NodeImage`
        :rtype: ``list``
        """
        response = self.connection.request(
            action='server_appliances',
            method='GET'
        )

return self._to_images(response.object, image_type)

def get_image(self, image_id):
        response = self.connection.request(
            action='server_appliances/%s' % image_id,
            method='GET'
        )
        return self._to_image(response.object)

"""
    Node functions
    """

def create_node(self,
                    name,
                    image,
                    ex_fixed_instance_size_id,
                    location=None,
                    auth=None,
                    ex_ip=None,
                    ex_monitoring_policy_id=None,
                    ex_firewall_policy_id=None,
                    ex_loadbalancer_id=None,
                    ex_description=None,
                    ex_power_on=None):
        """
        Creates a node.

:param name: The name of the new node
        :type name: `str`

:param ex_fixed_instance_size_id:
        Fixed instance size ID from list_sizes
        :type ex_fixed_instance_size_id: ``str``

:param location: 1&1 Data center Location
        :type location: `NodeLocation`

:param ex_ip: IP address
        :type ex_ip: `str`

:param ex_ssh_key: SSH Key
        :type ex_ssh_key: `str`

:param password: Password
        :type password: `str`

:param ex_monitoring_policy_id:
        :type ex_firewall_policy_id: `str`

:param ex_firewall_policy_id:
        :type ex_firewall_policy_id: `str`

:param ex_loadbalancer_id:
        :type ex_loadbalancer_id: `str`

:param ex_description:
        :type ex_description: `str`

:param ex_power_on:
        :type ex_power_on: `bool`

:return:    Instance of class ``Node``
        :rtype:     :class:`Node`
        """

body = {
            'name': name,
            'appliance_id': image.id,
            'hardware': {
                'fixed_instance_size_id': ex_fixed_instance_size_id
            },
        }

if location is not None:
            body['datacenter_id'] = location.id
        if ex_power_on is not None:
            body['power_on'] = ex_power_on

if ex_description is not None:
            body['description'] = ex_description

if ex_firewall_policy_id is not None:
            body['firewall_policy_id'] = ex_firewall_policy_id

if ex_monitoring_policy_id is not None:
            body['monitoring_policy_id'] = ex_monitoring_policy_id

if ex_loadbalancer_id is not None:
            body['loadbalancer_id'] = ex_loadbalancer_id

if auth is not None:
            if isinstance(auth, NodeAuthPassword):
                body['password'] = auth.password
            elif isinstance(auth, NodeAuthSSHKey):
                body['rsa_key'] = auth.pubkey
        if ex_ip is not None:
            body['ip_id'] = ex_ip

response = self.connection.request(
            action='servers',
            data=body,
            method='POST',
        )

return self._to_node(response.object)

def list_nodes(self):
        """
        List all nodes.

:return: ``list`` of :class:`Node`
        :rtype: ``list``
        """
        response = self.connection.request(
            action='servers',
            method='GET'
        )

return self._to_nodes(response.object)

def destroy_node(self, node, ex_keep_ips=False):
        """
        Destroys a node.

:param node: The node you wish to destroy.
        :type volume: :class:`Node`

:param ex_keep_ips: True to keep all IP addresses assigned to the node
        :type ex_keep_ips: : ``bool``

:return:    Instance of class ``Node``
        :rtype:     :class: `Node`
        """
        self.ex_shutdown_server(node.id)

self._wait_for_state(node.id, 'POWERED_OFF')

response = self.connection.request(
            action='servers/%s' % node.id,
            params={'keep_ips': ex_keep_ips},
            method='DELETE'
        )

return self._to_node(response.object)

def reboot_node(self, node):
        """
        Reboots the node.

:param node: The node you wish to destroy.
        :type volume: :class:`Node`

:return:    Instance of class ``Node``
        :rtype:     :class: `Node`
        """
        shutdown_body = {
            "action": "REBOOT",
            "method": "HARDWARE"
        }
        response = self.connection.request(
            action='servers/%s/status/action' % node.id,
            data=shutdown_body,
            method='PUT',
        )
        return self._to_node(response.object)

"""
    Extension functions
    """

def ex_rename_server(self, server_id, name=None, description=None):
        """
        Renames the server
        :param  server_id: ID of the server you want to rename

:param  name: New name of the server
        :type: ``str``

:param description: New description of the server
        :type: ``str``

:return:    Instance of class ``Node``
        :rtype:     :class: `Node`
        """

body = {}
        if name is not None:
            body["name"] = name
        if description is not None:
            body["description"] = description

response = self.connection.request(
            action='servers/%s' % server_id,
            data=body,
            method='PUT'
        )

return self._to_node(response.object)

def ex_get_server_hardware(self, server_id):
        """
        Gets all server hardware

:param server_id: Id of the server
        :type: ``str``

:return: Server's hardware
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='servers/%s/hardware' % server_id,
            method='GET'
        )
        return response.object

"""
    Hardware operations
    """

def ex_modify_server_hardware(self, server_id,
                                  fixed_instance_size_id=None, vcore=None,
                                  cores_per_processor=None, ram=None):
        """
        Modifies server's hardware

:param server_id:
        :type: ``str``

:param fixed_instance_size_id: Id of the fixed instance size
        :type: ``str``

:param vcore: Virtual cores count
        :type: ``int``

:param cores_per_processor: Count of cores per procesor
        :type: ``int``

:param ram: Amount of ram for the server
        :type: ``int``

:return:    Instance of class ``Node``
        :type:     :class: `Node`
        """

body = {}

if fixed_instance_size_id is not None:
            body['fixed_instance_size_id'] = fixed_instance_size_id
        if vcore is not None:
            body['vcore'] = vcore
        if cores_per_processor is not None:
            body['cores_per_processor'] = cores_per_processor
        if ram is not None:
            body['ram'] = ram

response = self.connection.request(
            action='servers/%s/hardware' % server_id,
            data=body,
            method='PUT'
        )

return self._to_node(response.object)

"""
    HDD operations
    """

def ex_modify_server_hdd(self, server_id, hdd_id=None, size=None):
        """
        Modifies server hard disk drives

:param server_id: Id of the server
        :type: ``str``

:param hdd_id: Id of the hard disk
        :type: ``str``

:param size: Size of the hard disk
        :type: ``str``

:return:    Instance of class ``Node``
        :rtype:     :class: `Node`
        """

body = {}

if size is not None:
            body['size'] = size

response = self.connection.request(
                action='servers/%s/hardware/hdds/%s' % (server_id, hdd_id),
                data=body,
                method='PUT'
            )

return self._to_node(response.object)

def ex_add_hdd(self, server_id, size, is_main):
        """
        Add a hard disk to the server

:param server_id: Id of the server
        :type: ``str``

:param size: Size of the new disk
        :type: ``str``

:param is_main: Indicates if the disk is going to be the boot disk
        :type: ``boolean``

:return:    Instance of class ``Node``
        :type:     :class: `Node`
        """
        body = {
            'size': size,
            'is_main': is_main
        }

response = self.connection.request(
            action='servers/%s/hardware/hdds' % server_id,
            data=body,
            method='POST'
        )

return self._to_node(response.object)

def ex_remove_hdd(self, server_id, hdd_id):
        """
        Removes existing hard disk

:param server_id: Id of the server
        :type: ``str``

:param hdd_id: Id of the hard disk
        :type: ``str``

:return:    Instance of class ``Node``
        :rtype:     :class: `Node`
        """

response = self.connection.request(
            action='servers/%s/hardware/hdds/%s' % (server_id, hdd_id),
            method='DELETE'
        )

return self._to_node(response.object)

"""
    Data center operations
    """

def ex_list_datacenters(self):
        """
        Lists all data centers

:return: List of data centers
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='datacenters',
            method='GET'
        )

return response.object

def ex_get_server(self, server_id):
        """
        Gets a server

:param server_id: Id of the server to be retrieved
        :type: ``str``

:return:    Instance of class ``Node``
        :rtype:     :class: `Node`
        """

response = self.connection.request(
            action='servers/%s' % (server_id),
            method='GET'
        )

return self._to_node(response.object)

def ex_shutdown_server(self, server_id, method='SOFTWARE'):
        """
        Shuts down the server

:param server_id: Id of the server to be shut down
        :type: ``str``

:param method: Method of shutting down "SOFTWARE" or "HARDWARE"

:return:    Instance of class ``Node``
        :rtype:     :class: `Node`
        """

shutdown_body = {
            'action': 'POWER_OFF',
            'method': method
        }
        response = self.connection.request(
            action='servers/%s/status/action' % (server_id),
            data=shutdown_body,
            method='PUT',
        )
        return self._to_node(response.object)

"""
    Image operations
    """

def ex_get_server_image(self, server_id):
        """
        Gets server image

:param server_id: Id of the server
        :type: ``str``

:return: Server image
        :rtype: ``dict``
        """

response = self.connection.request(
            action='servers/%s/image' % server_id,
            method='GET'
        )
        return response.object

def ex_reinstall_server_image(self, server_id, image_id, password=None):
        """
        Installs a new image on the server

:param server_id: Id of the server
        :type: ``str``

:param image_id: Id of the image (Server Appliance)
        :type: ``str``

:param password: New password for the server

:return:    Instance of class ``Node``
        :rtype:     :class: `Node`
        """

body = {
            'id': image_id,
        }

if password is not None:
            body['password'] = password

response = self.connection.request(
            action='servers/%s/image' % server_id,
            data=body,
            method='PUT'
        )
        return self._to_node(response.object)

"""
    Server IP operations
    """

def ex_list_server_ips(self, server_id):
        """
        Gets all server IP objects

:param server_id: Id of the server
        :type: ``str``

:return: List of server IP objects
        :rtype: ``list`` of ``dict``
        """
        response = self.connection.request(
            action='servers/%s/ips' % server_id,
            method='GET'
        )

return response.object

def ex_get_server_ip(self, server_id, ip_id):
        """
        Get a single server IP object

:param server_id: Id of the server
        :type: ``str``

:param ip_id: ID of the IP address
        :type: ``str``

:return: IP address object
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='servers/%s/ips/%s' % (server_id, ip_id),
            method='GET'
        )

return response.object

def ex_assign_server_ip(self, server_id, ip_type):
        """
        Assigns a new IP address to the server

:param server_id: Id of the server
        :type: ``str``

:param ip_type: Type of the IP address [IPV4,IPV6]
        :type: ``str``

:return: ``Node`` instance
        :rtype: ``Node``
        """

body = {
            'type': ip_type
        }

response = self.connection.request(
            action='servers/%s/ips' % server_id,
            data=body,
            method='POST'
        )

return self._to_node(response.object)

def ex_remove_server_ip(self, server_id, ip_id, keep_ip=None):
        """
        Removes an IP address from the server

:param server_id: Id of the server
        :type: ``str``

:param ip_id: ID of the IP address
        :type: ``str``

:param keep_ip: Indicates whether IP address will be removed from
                        the Cloud Panel
        :type: ``boolean``

:return: ``Node`` instance
        :rtype: ``Node``
        """

body = {}
        if keep_ip is not None:
            body['keep_ip'] = keep_ip

response = self.connection.request(
            action='servers/%s/ips/%s' % (server_id, ip_id),
            data=body,
            method='DELETE'
        )

return self._to_node(response.object)

def ex_get_server_firewall_policies(self, server_id, ip_id):
        """
        Gets a firewall policy of attached to the server's IP

:param server_id: Id of the server
        :type: ``str``

:param ip_id: ID of the IP address
        :type: ``str``

:return: IP address object
        :rtype: ``dict``
        """

response = self.connection.request(
            action='/servers/%s/ips/%s/firewall_policy' % (server_id, ip_id),
            method='GET'
        )

return response.object

def ex_add_server_firewall_policy(self, server_id, ip_id, firewall_id):
        """
        Adds a firewall policy to the server's IP address

:param server_id: Id of the server
        :type: ``str``

:param ip_id: ID of the IP address
        :type: ``str``

:param firewall_id: ID of the firewall policy
        :type: ``str``

:return: ``Node`` instance
        :rtype: ``Node``
        """
        body = {
            'id': firewall_id
        }
        response = self.connection.request(
            action='/servers/%s/ips/%s/firewall_policy' % (server_id, ip_id),
            data=body,
            method='POST'
        )

return self._to_node(response.object)

"""
    Firewall Policy operations
    """

def ex_create_firewall_policy(self, name, rules, description=None):
        """
        Creates a firewall Policy.

:param name:
        :param description:
        :param rules:

:rtype: `dict`
        :return: `dict` firewall policy

"""
        body = {
            'name': name
        }

if description is not None:
            body['description'] = description

if len(rules) == 0:
            raise ValueError(
                'At least one firewall rule is required.'
            )
        else:
            body['rules'] = rules

response = self.connection.request(
            action='firewall_policies',
            data=body,
            method='POST',
        )

return response.object

def ex_list_firewall_policies(self):
        """"
        List firewall policies

:return: 'dict'
        """

response = self.connection.request(
            action='firewall_policies',
            method='GET'
        )

return response.object

def ex_get_firewall_policy(self, fw_id):
        """
        Gets firewall policy

:param fw_id: ID of the firewall policy
        :return: 'dict'
        """

response = self.connection.request(
            action='firewall_policy/%s' % fw_id,
            method='GET'
        )

return response.object

def ex_delete_firewall_policy(self, fw_id):
        """
        Deletes firewall policy

:param fw_id: ID of the Firewall
        :return: 'dict'
        """
        response = self.connection.request(
            action='firewall_policy/%s' % fw_id,
            method='DELETE'
        )

return response.object

"""
    Shared storage operations
    """

def ex_list_shared_storages(self):
        """
        List of shared storages
        :return: 'dict'
        """
        response = self.connection.request(
            action='shared_storages',
            method='GET'
        )

return response.object

def ex_get_shared_storage(self, storage_id):
        """
        Gets a shared storage
        :return: 'dict'
        """
        response = self.connection.request(
            action='shared_storages/%s' % (storage_id),
            method='GET'
        )

return response.object

def ex_create_shared_storage(self, name, size, datacenter_id=None,
                                 description=None):
        """
        Creates a shared storage
        :param name: Name of the storage
        :param size: Size of the storage
        :param datacenter_id: datacenter where storage should be created
        :param description: description ot the  storage
        :return: 'dict'
        """

body = {
            'name': name,
            'size': size,
            'datacenter_id': datacenter_id
        }

if description is not None:
            body['description'] = description

response = self.connection.request(
            action='shared_storages',
            data=body,
            method='POST'
        )

return response.object

def ex_delete_shared_storage(self, storage_id):
        """
        Removes a shared storage

:param storage_id: Id of the shared storage
        :type: ``str``

:return: Instnace of shared storage
        :rtype: ``list`` of ``dict``
        """
        response = self.connection.request(
            action='shared_storages/%s' % storage_id,
            method='DELETE'
        )

return response.object

def ex_attach_server_to_shared_storage(self, storage_id,
                                           server_id, rights):
        """
        Attaches a single server to a shared storage

:param storage_id: Id of the shared storage
        :param server_id: Id of the server to be attached to the shared storage
        :param rights:
        :return:
        :rtype: 'dict'
        """
        body = {
            'severs': [
                {
                    'id': server_id,
                    'rights': rights
                }
            ]
        }

response = self.connection.request(
            action='shared_storages/%s/servers' % storage_id,
            data=body,
            method='POST'
        )

return response.object

def ex_get_shared_storage_server(self, storage_id, server_id):
        """
        Gets a shared storage's server
        :param storage_id:
        :param server_id:
        :return:
        """
        response = self.connection.request(
            action='shared_storages/%s/servers/%s' % (storage_id, server_id),
        )

return response.object

def ex_detach_server_from_shared_storage(self, storage_id,
                                             server_id):
        """
        Detaches a server from shared storage

:param storage_id: Id of the shared storage
        :type: ``str``

:param server_id: Id of the server
        :type: ``str``

:return: Instance of shared storage
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='shared_storages/%s/servers/%s' % (storage_id, server_id),
            method='DELETE'
        )

return response.object

"""
    Load Balancers operations
    """

def ex_create_load_balancer(self, name, method, rules,
                                persistence=None,
                                persistence_time=None,
                                health_check_test=None,
                                health_check_interval=None,
                                health_check_path=None,
                                health_check_parser=None,
                                datacenter_id=None,
                                description=None):
        """

:param name: Name of the load balancer

:param method: Load balancer method

:param rules: Load balancer rules
        :type rules: ``list`` of ``dict``

:param persistence: Indictes if persistance is set
        :type persistence: ``boolean``

:param persistence_time: Persistance time
        :type persistence_time: ``int``

:param health_check_test: Type of test
        :type health_check_test:``str``

:param health_check_interval: Interval of the check

:param health_check_path: Path
        :type health_check_path: ``str``

:param health_check_parser: Parser
        :type health_check_parser:``str``

:param datacenter_id: Data center id
        :type datacenter_id:``str``

:param description: Description of load balancer
        :type description:``str``

:return: ``dict``
        """

body = {
            'name': name,
            'method': method,
        }

body['rules'] = []
        body['rules'] = rules

if persistence is not None:
            body['persistence'] = persistence
        if persistence_time is not None:
            body['persistence_time'] = persistence_time
        if health_check_test is not None:
            body['health_check_test'] = health_check_test
        if health_check_interval is not None:
            body['health_check_interval'] = health_check_interval
        if health_check_path is not None:
            body['health_check_path'] = health_check_path
        if health_check_parser is not None:
            body['health_check_parser'] = health_check_parser
        if datacenter_id is not None:
            body['datacenter_id'] = datacenter_id
        if description is not None:
            body['description'] = description

response = self.connection.request(
            action='load_balancers',
            data=body,
            method='POST'
        )

return response.object

def ex_update_load_balancer(self, lb_id, name=None, description=None,
                                health_check_test=None,
                                health_check_interval=None,
                                persistence=None,
                                persistence_time=None,
                                method=None):
        body = {}

if name is not None:
            body['name'] = name
        if description is not None:
            body['description'] = description
        if health_check_test is not None:
            body['health_check_test'] = health_check_test
        if health_check_interval is not None:
            body['health_check_interval'] = health_check_interval
        if persistence is not None:
            body['persistence'] = persistence
        if persistence_time is not None:
            body['persistence_time'] = persistence_time
        if method is not None:
            body['method'] = method

response = self.connection.request(
            action='load_balancers/%s' % lb_id,
            data=body,
            method='PUT'
        )

return response.object

def ex_add_servers_to_load_balancer(self, lb_id, server_ips=[]):
        """
        Adds server's IP address to load balancer

:param lb_id: Load balancer ID
        :type: ``str``

:param server_ips: Array of server IP IDs
        :type: ``list`` of ``str``

:return: Instance of load balancer
        :rtype: ``dict``
        """
        body = {
            'server_ips': server_ips,
        }

response = self.connection.request(
            action='load_balancers/%s/server_ips' % lb_id,
            data=body,
            method='POST'
        )

return response.object

def ex_remove_server_from_load_balancer(self, lb_id, server_ip):
        """
        Removes server's IP from load balancer

:param lb_id: Load balancer ID
        :type: ``str``

:param server_ip: ID of the server IP
        :type: ``str``

:return: Instance of load balancer
        :rtype: ``dict``
        """

response = self.connection.request(
            action='/load_balancers/%s/server_ips/%s' % (lb_id, server_ip),
            method='DELETE'
        )

return response.object

def ex_add_load_balancer_rule(self, lb_id, protocol, port_balancer,
                                  port_server, source=None):
        """
        Adds a rule to load balancer

:param lb_id: Load balancer ID
        :rtype: ``str``

:param protocol: Load balancer protocol
        :rtype: ``str``

:param port_balancer: Port to be balananced
        :rtype: ``int``

:param port_server: Server port
        :rtype: ``int``

:param source: Source IP address
        :rtype: ``str``

:return: Instance of load balancer
        :rtype: ``dict``
        """

body = {
            'rules': [
                {
                    'protocol': protocol,
                    'port_balancer': port_balancer,
                    'port_server': port_server
                }
            ]
        }

if source is not None:
            body['rules'][0]['source'] = source

response = self.connection.request(
            action='/load_balancers/%s/rules' % lb_id,
            data=body,
            method='POST'
        )

return response.object

def ex_remove_load_balancer_rule(self, lb_id, rule_id):
        """
        Removes load balancer rule

:param lb_id: Load balancer ID
        :rtype: ``str``

:param rule_id: Rule ID
        :rtype: ``str``

:return: Instance of load balancer
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='/load_balancers/%s/rules/%s' % (lb_id, rule_id),
            method='DELETE'
        )

return response.object

def ex_list_load_balancers(self):
        """
        Lists all load balancers

:return: List of load balancers
        :rtype: ``list`` of ``dict``
        """
        response = self.connection.request(
            action='load_balancers',
            method='GET'
        )
        return response.object

def ex_get_load_balancer(self, lb_id):
        """
        Gets a single load balancer

:param lb_id: ID of the load balancer
        :type lb_id: ``str``

:return: Instance of load balancer
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='load_balancers/%s' % lb_id,
            method='GET'
        )

return response.object

def ex_list_load_balancer_server_ips(self, lb_id):
        """
        List balanced server IP addresses

:param lb_id: ID of the load balancer
        :type lb_id: ``str``

:return: Array of IP address IDs
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='load_balancers/%s/server_ips' % lb_id,
            method='GET'
        )

return response.object

def ex_get_load_balancer_server_ip(self, lb_id, server_ip):
        """
        Gets load balanced server id

:param lb_id: ID of the load balancer
        :type lb_id: ``str``

:param server_ip: ID of the server IP
        :type server_ip: ``str``

:return: Server IP
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='load_balancers/%s/server_ips/%s' % (lb_id, server_ip),
            method='GET'
        )

return response.object

def ex_list_load_balancer_rules(self, lb_id):
        """
        Lists loadbalancer rules

:param lb_id: ID of the load balancer
        :type lb_id: ``str``

:return: Lists of rules
        :rtype: ``list`` of ``dict``
        """
        response = self.connection.request(
            action='load_balancers/%s/rules' % lb_id,
            method='GET'
        )

return response.object

def ex_get_load_balancer_rule(self, lb_id, rule_id):
        """
        Get a load balancer rule

:param lb_id: ID of the load balancer
        :type lb_id: ``str``

:param rule_id: Rule ID
        :type rule_id: ``str``

:return: A load balancer rule
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='load_balancers/%s/rules/%s' % (lb_id, rule_id),
            method='GET'
        )

return response.object

def ex_delete_load_balancer(self, lb_id):
        """
        Deletes a load balancer rule

:param lb_id: ID of the load balancer
        :type lb_id: ``str``

:param rule_id: Rule ID
        :type rule_id: ``str``

:return: Instance of load balancer
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='load_balancers/%s' % lb_id,
            method='DELETE'
        )

return response.object

"""
    Public IP operations
    """

def ex_list_public_ips(self):
        """
        Lists all public IP addresses

:return: Array of public addresses
        :rtype: ``list`` of ``dict``
        """
        response = self.connection.request(
            action='public_ips',
            method='GET'
        )

return response.object

def ex_create_public_ip(self, type, reverse_dns=None, datacenter_id=None):
        """
        Creates a public IP

:param type: Type of IP (IPV4 or IPV6)
        :type type: ``str``

:param reverse_dns: Reverse DNS
        :type reverse_dns: ``str``

:param datacenter_id: Datacenter ID where IP address will be crated
        :type datacenter_id: ``str``

:return: Instance of Public IP
        :rtype: ``dict``
        """
        body = {
            'type': type
        }

if reverse_dns is not None:
            body['reverse_dns'] = reverse_dns
        if datacenter_id is not None:
            body['datacenter_id'] = datacenter_id

response = self.connection.request(
            action='public_ips',
            data=body,
            method='POST'
        )

return response.object

def ex_get_public_ip(self, ip_id):
        """
        Gets a Public IP

:param ip_id: ID of the IP
        :type ip_id: ``str``

:return: Instance of Public IP
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='public_ips/%s' % ip_id,
            method='GET'
        )

return response.object

def ex_delete_public_ip(self, ip_id):
        """
        Deletes a public IP

:param ip_id: ID of public IP
        :type ip_id: ``str``

:return: Instance of IP Address
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='public_ips/%s' % ip_id,
            method='DELETE'
        )

return response

def ex_update_public_ip(self, ip_id, reverse_dns):
        """
        Updates a Public IP

:param ip_id: ID of public IP
        :type ip_id: ``str``

:param reverse_dns: Reverse DNS
        :type reverse_dns: ``str``

:return: Instance of Public IP
        :rtype: ``dict``
        """

body = {
            'reverse_dns': reverse_dns
        }
        response = self.connection.request(
            action='public_ips/%s' % ip_id,
            data=body,
            method='DELETE'
        )

return response.object

"""
    Private Network Operations
    """

def ex_list_private_networks(self):
        """
        Lists all private networks

:return: List of private networks
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='private_networks',
            method='GET'
        )

return response.object

def ex_create_private_network(self, name, description=None,
                                  datacenter_id=None,
                                  network_address=None,
                                  subnet_mask=None):
        """
        Creates a private network

:param name: Name of the private network
        :type name: ``str``

:param description: Description of the private network
        :type description: ``str``

:param datacenter_id: ID of the data center for the private network
        :type datacenter_id: ``str``

:param network_address: Network address of the private network
        :type network_address: ``str``

:param subnet_mask: Subnet mask of the private network
        :type subnet_mask: ``str``

:return: Newly created private network
        :rtype: ``dict``
        """

body = {
            'name': name
        }

if description is not None:
            body['description'] = description
        if datacenter_id is not None:
            body['datacenter_id'] = datacenter_id
        if network_address is not None:
            body['network_address'] = network_address
        if subnet_mask is not None:
            body['subnet_maks'] = subnet_mask

response = self.connection.request(
            action='private_networks',
            data=body,
            method='POST'
        )
        return response.object

def ex_delete_private_network(self, network_id):
        """
        Deletes a private network

:param network_id: Id of the private network
        :type network_id: ``str``

:return: Instance of the private network being deleted
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='private_networks' % network_id,
            method='DELETE'
        )

return response.object

def ex_update_private_network(self, network_id,
                                  name=None, description=None,
                                  datacenter_id=None,
                                  network_address=None,
                                  subnet_mask=None):
        """
       Updates a private network

:param name: Name of the private network
       :type name: ``str``

:param description: Description of the private network
       :type description: ``str``

:param datacenter_id: ID of the data center for the private network
       :type datacenter_id: ``str``

:param network_address: Network address of the private network
       :type network_address: ``str``

:param subnet_mask: Subnet mask of the private network
       :type subnet_mask: ``str``

:return: Instance of private network
       :rtype: ``dict``
       """
        body = {}

if name is not None:
            body['name'] = name
        if description is not None:
            body['description'] = description
        if datacenter_id is not None:
            body['datacenter_id'] = datacenter_id
        if network_address is not None:
            body['network_address'] = network_address
        if subnet_mask is not None:
            body['subnet_maks'] = subnet_mask

response = self.connection.request(
            action='private_networks/%s',
            data=body,
            method='PUT'
        )

return response.object

def ex_list_private_network_servers(self, network_id):
        """
        Lists all private network servers

:param network_id: Private network ID
        :type network_id: ``str``

:return: List of private network servers
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='/private_networks/%s/servers' % network_id,
            method='GET'
        )
        return response.object

def ex_add_private_network_server(self, network_id, server_ids):
        """
        Add servers to private network

:param network_id: Private Network ID
        :type network_id: ``str``

:param server_ids: List of server IDs
        :type server_ids: ``list`` of ``str``

:return: List of attached servers
        :rtype: ``dict``

"""
        body = {
            'servers': server_ids

}

response = self.connection.request(
            action='/private_networks/%s/servers' % network_id,
            data=body,
            method='POST'
        )

return response.object

def ex_remove_server_from_private_network(self, network_id, server_id):
        """
        Removes a server from the private network

:param network_id: Private Network ID
        :type network_id: ``str``

:param server_id: Id of the server
        :type server_id: ``str``

:return: Instance of the private network
        :rtype: ``dict``
        """

response = self.connection.request(
            action='/private_networks/%s/servers/%s' % (network_id, server_id),
            method='POST'
        )
        return response.object

"""
    Monitoring policy operations
    """

def ex_list_monitoring_policies(self):
        """
        Lists all monitoring policies

:return: List of monitoring policies
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='monitoring_policies',
            method='GET'
        )

return response.object

def ex_create_monitoring_policy(self, name, thresholds,
                                    ports,
                                    processes,
                                    description=None,
                                    email=None,
                                    agent=None,
                                    ):
        """
        Creates a monitoring policy

:param name: Name for the monitoring policy
        :type name: ``str``

:param thresholds: Thresholds for the monitoring policy
        :type thresholds: ``dict``

:param ports: Monitoring policies for ports
        :type ports: ``list`` of ``dict``

:param processes: Processes to be monitored
        :type processes: ``list`` of ``dict``

:param description: Description for the monitoring policy
        :type description: ``str``

:param email: Email for notifications
        :type email: ``str``

:param agent: Indicates if agent application will be installed
        :type agent: ``boolean``

:return: Newly created instance of monitofing policy
        :rtype: ``dict``
        """
        body = {
            'name': name,
            'thresholds': thresholds,
            'ports': ports,
            'processes': processes
        }

if description is not None:
            body['description'] = description
        if email is not None:
            body['email'] = email
        if agent is not None:
            body['agent'] = agent

response = self.connection.request(
            action='monitoring_policies',
            data=body,
            method='POST'
        )
        return response.object

def ex_delete_monitoring_policy(self, policy_id):
        """
        Deletes a monitoring policy

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:return: Instance of the monitoring policy being deleted
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='monitoring_policies' % policy_id,
            method='DELETE'
        )

return response.object

def ex_update_monitoring_policy(self, policy_id,
                                    email,
                                    thresholds,
                                    name=None, description=None):
        """
        Updates monitoring policy

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:param email: Email to send notifications to
        :type email: ``str``

:param thresholds: Thresholds for the monitoring policy
        :type thresholds: ``dict``

:param name: Name of the monitoring policy
        :type name: ``str``

:param description: Description of the monitoring policy
        :type description: ``str``

:return: Instance of the monitoring policy being deleted
        :rtype: ``dict``
        """

body = {}

if name is not None:
            body['name'] = name
        if description is not None:
            body['description'] = description
        if thresholds is not None:
            body['thresholds'] = thresholds
        if email is not None:
            body['email'] = email

response = self.connection.request(
            action='monitoring_policies/%s' % policy_id,
            data=body,
            method='PUT'
        )

return response.object

def ex_get_monitoring_policy(self, policy_id):
        """
        Fetches a monitoring policy

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:return: Instance of a monitoring policy
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='monitoring_policies/%s' % policy_id,
            method='GET'
        )

return response.object

def ex_get_monitoring_policy_ports(self, policy_id):
        """
        Fetches monitoring policy ports

:param policy_id: Id of the monitoring policy
        :type policy_id:

:return: Instance of a monitoring policy
        :rtype: ``dict``
        """

response = self.connection.request(
            action='monitoring_policies/%s/ports' % policy_id,
            method='GET'
        )

return response.object

def ex_get_monitoring_policy_port(self, policy_id, port_id):
        """
        Fetches monitoring policy port

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:param port_id: Id of the port
        :type port_id: ``str``

:return: Instance of a monitoring policy
        :rtype: ``dict``
        """

response = self.connection.request(
            action='monitoring_policies/%s/ports/%s' % (policy_id, port_id),
            method='GET'
        )

return response.object

def ex_remove_monitoring_policy_port(self, policy_id, port_id):
        """
        Removes monitoring policy port

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:param port_id: Id of the port
        :type port_id: ``str``

:return: Instance of a monitoring policy
        :rtype: ``dict``
        """

response = self.connection.request(
            action='monitoring_policies/%s/ports/%s' % (policy_id, port_id),
            method='DELETE'
        )

return response.object

def ex_add_monitoring_policy_ports(self, policy_id, ports):
        """
        Add monitoring policy ports

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:param ports: List of ports
        :type ports: ``dict``
        [
           {
              'protocol':'TCP',
              'port':'80',
              'alert_if':'RESPONDING',
              'email_notification':true
           }
        ]

:return: Instance of a monitoring policy
        :rtype: ``dict``
        """

body = {'ports': ports}

response = self.connection.request(
            action='monitoring_policies/%s/ports' % policy_id,
            data=body,
            method='POST'
        )

return response.object

def ex_get_monitoring_policy_processes(self, policy_id):
        """
        Fetches monitoring policy processes

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:return: Instance of a monitoring policy
        :rtype: ``dict``
        """

response = self.connection.request(
            action='monitoring_policies/%s/processes' % policy_id,
            method='GET'
        )

return response.object

def ex_get_monitoring_policy_process(self, policy_id, process_id):
        """
        Fetches monitoring policy process

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:param process_id: Id of the process
        :type process_id: ``str``

:return: Instance of a monitoring policy
        :rtype: ``dict``
        """

response = self.connection.request(
            action='monitoring_policies/%s/processes/%s'
                   % (policy_id, process_id),
            method='GET'
        )

return response.object

def ex_remove_monitoring_policy_process(self, policy_id, process_id):
        """
        Removes monitoring policy process

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:param process_id: Id of the process
        :type process_id: ``str``

:return: Instance of a monitoring policy
        :rtype: ``dict``
        """

response = self.connection.request(
            action='monitoring_policies/%s/processes/%s'
                   % (policy_id, process_id),
            method='DELETE'
        )

return response.object

def ex_add_monitoring_policy_processes(self, policy_id, processes):
        """
        Add monitoring policy processes

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:param processes: List of processes
        :type processes: ``list`` of ``dict``
        [
          {
            'process': 'taskmmgr',
            'alert_if': 'RUNNING',
            'email_notification': true
          }
        ]

:return: Instance of a monitoring policy
        :rtype: ``dict``
        """

body = {'processes': processes}

response = self.connection.request(
            action='monitoring_policies/%s/processes' % policy_id,
            data=body,
            method='POST'
        )

return response.object

def ex_list_monitoring_policy_servers(self, policy_id):
        """
        List all servers that are being monitoried by the policy

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:return: List of servers being monitored
        :rtype: ``list`` of ``dict``
        """

response = self.connection.request(
            action='monitoring_policies/%s/servers' % policy_id,
            method='GET'
        )

return response.object

def ex_add_servers_to_monitoring_policy(self, policy_id, servers):
        """
        Adds servers to monitoring policy

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:param servers: List of server ID
        :type servers: ``list`` of ``str``

:return: Instance of a monitoring policy
        :rtype: ``dict``
        """
        body = {
            'servers': servers
        }
        response = self.connection.request(
            action='monitoring_policies/%s/servers' % policy_id,
            data=body,
            method='POST'
        )

return response.object

def ex_remove_server_from_monitoring_policy(self, policy_id, server_id):
        """
        Removes a server from monitoring policy

:param policy_id: Id of the monitoring policy
        :type policy_id: ``str``

:param server_id: Id of the server
        :type server_id: ``str``

:return: Instance of a monitoring policy
        :rtype: ``dict``
        """
        response = self.connection.request(
            action='monitoring_policies/%s/servers/%s'
                   % (policy_id, server_id),
            method='DELETE'
        )

return response.object

"""
    Private Functions
    """

def _to_images(self, object, image_type=None):
        if image_type is not None:
            images = [image for image in object if image['type'] == image_type]
        else:
            images = [image for image in object]

return [self._to_image(image) for image in images]

def _to_image(self, data):
        extra = {
            'os_family': data['os_family'],
            'os': data['os'],
            'os_version': data['os_version'],
            'os_architecture': data['os_architecture'],
            'os_image_type': data['os_image_type'],
            'min_hdd_size': data['min_hdd_size'],
            'available_datacenters': data['available_datacenters'],
            'licenses': data['licenses'],
            'version': data['version'],
            'categories': data['categories']
        }
        return NodeImage(id=data['id'], name=data['name'], driver=self,
                         extra=extra)

def _to_node_size(self, data):
        return NodeSize(
            id=data['id'],
            name=data['name'],
            ram=data['hardware']['ram'],
            disk=data['hardware']['hdds'][0]['size'],
            bandwidth=None,
            price=None,
            driver=self.connection.driver,
            extra={
                'vcores': data['hardware']['vcore'],
                'cores_per_processor': data['hardware']['cores_per_processor']}

)

def _to_location(self, location):
        return NodeLocation(
            id=location['id'],
            name=location['country_code'],
            country=location['location'],
            driver=self.connection.driver
        )

def _to_nodes(self, servers):
        return [self._to_node(
            server) for server in servers]

def _to_node(self, server):
        extra = {}
        extra['datacenter'] = server['datacenter']

if 'description' in server:
            extra['description'] = server['description']
        if 'status' in server:
            extra['status'] = server['status']
        if 'image' in server:
            extra['image'] = server['image']
        if 'hardware' in server:
            extra['hardware'] = server['hardware']
        if 'dvd' in server:
            extra['dvd'] = server['dvd']
        if 'snapshot' in server:
            extra['snapshot'] = server['snapshot']
        if 'ips' in server:
            extra['ips'] = server['ips']
        if 'alerts' in server:
            extra['alerts'] = server['alerts']
        if 'monitoring_policy' in server:
            extra['monitoring_policy'] = server['monitoring_policy']
        if 'private_networks' in server:
            extra['private_networks'] = server['private_networks']

ips = []

if server['ips'] is not None:
            for ip in server['ips']:
                ips.append(ip['ip'])
        state = self.NODE_STATE_MAP.get(
            server['status']['state'])

return Node(
            id=server['id'],
            state=state,
            name=server['name'],
            driver=self.connection.driver,
            public_ips=ips,
            private_ips=None,
            extra=extra
        )

def _wait_for_state(self, server_id, state, retries=50):
        for i in (0, retries):
            server = self.ex_get_server(server_id)

if server.extra['status']['state'] == state:
                return
            sleep(5)

if i == retries:
                raise Exception('Retries count reached')

def _list_fixed_instances(self):
        response = self.connection.request(
            action='/servers/fixed_instance_sizes',
            method='GET'
        )

return response.object

cmd: