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/kamatera.py (23481B)

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

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

class KamateraResponse(JsonResponse):
    """
    Response class for KamateraDriver
    """

def parse_error(self):
        data = self.parse_body()
        if 'message' in data:
            return data['message']
        else:
            return json.dumps(data)

class KamateraConnection(ConnectionUserAndKey):
    """
    Connection class for KamateraDriver
    """

host = 'cloudcli.cloudwm.com'
    responseCls = KamateraResponse

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

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 = 'https://www.kamatera.com/'
    connectionCls = KamateraConnection
    features = {'create_node': ['password', 'generates_password', 'ssh_key']}

EX_BILLINGCYCLE_HOURLY = 'hourly'
    EX_BILLINGCYCLE_MONTHLY = 'monthly'

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]

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' % location.id)
        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]

def list_images(self, location):
        """
        List available disk images.

:param location: Location of the deployement.
                         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' % location.id)
        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

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": location.id,
            "image": image.id,
            "cpu": '%s%s' % (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([
                '%s=%s' % (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')
            node.name = name_lines[0].replace('Name: ', '')
            response = self.connection.request(
                '/service/server/info', method='POST',
                data=json.dumps({'name': node.name}))
            self._update_node_from_server_info(node, response.object[0])
        return node

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]

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)

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)

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)

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)

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 node.id:
            request_data = {'id': node.id}
        elif node.name:
            request_data = {'name': node.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

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)

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 []
            }
        )

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 {})

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' % location.id).object

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 = datetime.datetime.now()
        time.sleep(poll_interval_seconds)
        while True:
            max_time = start_time + datetime.timedelta(
                seconds=timeout_seconds)
            if max_time < datetime.datetime.now():
                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'))

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]

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):
        node.id = server['id']
        node.name = 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

cmd: