File Manager

003 File Manager

Current Path: /usr/local/lib/python3.8/site-packages/libcloud/compute/drivers

usr / local / lib / python3.8 / site-packages / libcloud / compute / drivers /

📁 ..
📄 __init__.py(1.18 KB)
📁 __pycache__
📄 abiquo.py(30.79 KB)
📄 auroracompute.py(1.99 KB)
📄 azure.py(110.57 KB)
📄 azure_arm.py(81.18 KB)
📄 bluebox.py(7.25 KB)
📄 brightbox.py(10.6 KB)
📄 bsnl.py(1.91 KB)
📄 cloudscale.py(8.64 KB)
📄 cloudsigma.py(67.16 KB)
📄 cloudstack.py(159.99 KB)
📄 cloudwatt.py(4.97 KB)
📄 digitalocean.py(26.89 KB)
📄 dimensiondata.py(185.11 KB)
📄 dummy.py(10.81 KB)
📄 ec2.py(216.23 KB)
📄 ecp.py(11.45 KB)
📄 ecs.py(62.32 KB)
📄 elastichosts.py(7.27 KB)
📄 elasticstack.py(15.96 KB)
📄 equinixmetal.py(33.73 KB)
📄 exoscale.py(1.13 KB)
📄 gandi.py(25.69 KB)
📄 gce.py(381.02 KB)
📄 gig_g8.py(21.5 KB)
📄 gogrid.py(14.89 KB)
📄 gridscale.py(34.55 KB)
📄 gridspot.py(4.14 KB)
📄 hostvirtual.py(14.09 KB)
📄 ikoula.py(1.14 KB)
📄 indosat.py(1.95 KB)
📄 internetsolutions.py(2 KB)
📄 joyent.py(8.02 KB)
📄 kamatera.py(22.93 KB)
📄 kili.py(3.12 KB)
📄 ktucloud.py(3.51 KB)
📄 kubevirt.py(50.35 KB)
📄 libvirt_driver.py(14.33 KB)
📄 linode.py(58.85 KB)
📄 maxihost.py(8.22 KB)
📄 medone.py(1.94 KB)
📄 nephoscale.py(17.28 KB)
📄 ntta.py(1.96 KB)
📄 nttcis.py(217.71 KB)
📄 onapp.py(16.12 KB)
📄 oneandone.py(56.4 KB)
📄 opennebula.py(42.33 KB)
📄 openstack.py(154.85 KB)
📄 outscale.py(285.94 KB)
📄 ovh.py(19.11 KB)
📄 profitbricks.py(117.97 KB)
📄 rackspace.py(9.22 KB)
📄 rimuhosting.py(12 KB)
📄 scaleway.py(23.66 KB)
📄 serverlove.py(2.87 KB)
📄 skalicloud.py(2.85 KB)
📄 softlayer.py(17.5 KB)
📄 upcloud.py(10.89 KB)
📄 vcl.py(8.64 KB)
📄 vcloud.py(92.5 KB)
📄 voxel.py(10.67 KB)
📄 vpsnet.py(6.56 KB)
📄 vsphere.py(76.51 KB)
📄 vultr.py(28.4 KB)

Editing: bluebox.py

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

"""
libcloud driver for the Blue Box Blocks API

This driver implements all libcloud functionality for the Blue Box Blocks API.

Blue Box home page            http://bluebox.net
Blue Box API documentation    https://boxpanel.bluebox
.net/public/the_vault/index.php/Blocks_API
"""

import copy
import base64

from libcloud.utils.py3 import urlencode
from libcloud.utils.py3 import b

from libcloud.common.base import JsonResponse, ConnectionUserAndKey
from libcloud.compute.providers import Provider
from libcloud.compute.types import NodeState, InvalidCredsError
from libcloud.compute.base import Node, NodeDriver
from libcloud.compute.base import NodeSize, NodeImage, NodeLocation
from libcloud.compute.base import NodeAuthPassword, NodeAuthSSHKey

# Current end point for Blue Box API.
BLUEBOX_API_HOST = "boxpanel.bluebox.net"

# The API doesn't currently expose all of the required values for libcloud,
# so we simply list what's available right now, along with all of the various
# attributes that are needed by libcloud.
BLUEBOX_INSTANCE_TYPES = {
    '1gb': {
        'id': '94fd37a7-2606-47f7-84d5-9000deda52ae',
        'name': 'Block 1GB Virtual Server',
        'ram': 1024,
        'disk': 20,
        'cpu': 0.5
    },
    '2gb': {
        'id': 'b412f354-5056-4bf0-a42f-6ddd998aa092',
        'name': 'Block 2GB Virtual Server',
        'ram': 2048,
        'disk': 25,
        'cpu': 1
    },
    '4gb': {
        'id': '0cd183d3-0287-4b1a-8288-b3ea8302ed58',
        'name': 'Block 4GB Virtual Server',
        'ram': 4096,
        'disk': 50,
        'cpu': 2
    },
    '8gb': {
        'id': 'b9b87a5b-2885-4a2e-b434-44a163ca6251',
        'name': 'Block 8GB Virtual Server',
        'ram': 8192,
        'disk': 100,
        'cpu': 4
    }
}

RAM_PER_CPU = 2048

NODE_STATE_MAP = {'queued': NodeState.PENDING,
                  'building': NodeState.PENDING,
                  'running': NodeState.RUNNING,
                  'error': NodeState.TERMINATED,
                  'unknown': NodeState.UNKNOWN}

class BlueboxResponse(JsonResponse):
    def parse_error(self):
        if int(self.status) == 401:
            if not self.body:
                raise InvalidCredsError(str(self.status) + ': ' + self.error)
            else:
                raise InvalidCredsError(self.body)
        return self.body

class BlueboxNodeSize(NodeSize):
    def __init__(self, id, name, cpu, ram, disk, price, driver):
        self.id = id
        self.name = name
        self.cpu = cpu
        self.ram = ram
        self.disk = disk
        self.price = price
        self.driver = driver

def __repr__(self):
        return ((
                '<NodeSize: id=%s, name=%s, cpu=%s, ram=%s, disk=%s, '
                'price=%s, driver=%s ...>')
                % (self.id, self.name, self.cpu, self.ram, self.disk,
                   self.price, self.driver.name))

class BlueboxConnection(ConnectionUserAndKey):
    """
    Connection class for the Bluebox driver
    """

host = BLUEBOX_API_HOST
    secure = True
    responseCls = BlueboxResponse

allow_insecure = False

def add_default_headers(self, headers):
        user_b64 = base64.b64encode(b('%s:%s' % (self.user_id, self.key)))
        headers['Authorization'] = 'Basic %s' % (user_b64)
        return headers

class BlueboxNodeDriver(NodeDriver):
    """
    Bluebox Blocks node driver
    """

connectionCls = BlueboxConnection
    type = Provider.BLUEBOX
    api_name = 'bluebox'
    name = 'Bluebox Blocks'
    website = 'http://bluebox.net'
    features = {'create_node': ['ssh_key', 'password']}

def list_nodes(self):
        result = self.connection.request('/api/blocks.json')
        return [self._to_node(i) for i in result.object]

def list_sizes(self, location=None):
        sizes = []
        for key, values in list(BLUEBOX_INSTANCE_TYPES.items()):
            attributes = copy.deepcopy(values)
            attributes.update({'price': self._get_size_price(size_id=key)})
            sizes.append(BlueboxNodeSize(driver=self.connection.driver,
                                         **attributes))

return sizes

def list_images(self, location=None):
        result = self.connection.request('/api/block_templates.json')
        images = []
        for image in result.object:
            images.extend([self._to_image(image)])

return images

def create_node(self, name, size, image, auth=None, ex_username=None):
        headers = {'Content-Type': 'application/x-www-form-urlencoded'}

auth = self._get_and_check_auth(auth)

data = {
            'hostname': name,
            'product': size.id,
            'template': image.id
        }

ssh = None
        password = None

if isinstance(auth, NodeAuthSSHKey):
            ssh = auth.pubkey  # pylint: disable=no-member
            data.update(ssh_public_key=ssh)
        elif isinstance(auth, NodeAuthPassword):
            password = auth.password
            data.update(password=password)

if ex_username:
            data.update(username=ex_username)

if not ssh and not password:
            raise Exception("SSH public key or password required.")

params = urlencode(data)
        result = self.connection.request('/api/blocks.json', headers=headers,
                                         data=params, method='POST')
        node = self._to_node(result.object)

if getattr(auth, "generated", False):
            node.extra['password'] = auth.password

return node

def destroy_node(self, node):
        url = '/api/blocks/%s.json' % (node.id)
        result = self.connection.request(url, method='DELETE')

return result.status == 200

def list_locations(self):
        return [NodeLocation(0, "Blue Box Seattle US", 'US', self)]

def reboot_node(self, node):
        url = '/api/blocks/%s/reboot.json' % (node.id)
        result = self.connection.request(url, method="PUT")
        return result.status == 200

def _to_node(self, vm):
        state = NODE_STATE_MAP[vm.get('status', NodeState.UNKNOWN)]
        n = Node(id=vm['id'],
                 name=vm['hostname'],
                 state=state,
                 public_ips=[ip['address'] for ip in vm['ips']],
                 private_ips=[],
                 extra={'storage': vm['storage'], 'cpu': vm['cpu']},
                 driver=self.connection.driver)
        return n

def _to_image(self, image):
        image = NodeImage(id=image['id'],
                          name=image['description'],
                          driver=self.connection.driver)
        return image

003 File Manager

Editing: bluebox.py

Upload File

Create Folder