CloudSigma Python util script

gistfile1.py

import requests
import json
import sys
import cloudsigma
import base64
import random
import string
import re
from urlparse import urlparse
from datetime import date
from time import sleep
from os import path

drive = cloudsigma.resource.Drive()
server = cloudsigma.resource.Server()
tags = cloudsigma.resource.Tags()
today = date.today()


def get_latest_trusty():
    """
    Returns the UUID of the latest Trusty image
    """

    base_url = urlparse(cloudsigma.conf.config['api_endpoint']).netloc
    dc = base_url.split('.')[0]
    feed = 'https://%s/streams/v1/com.ubuntu.cloud:release:cloudsigma.json' % base_url
    latest_uuid = None
    r = requests.get(feed)

    if r.status_code == 200:
        j = json.loads(r.content)
        trusty = j['products']['com.ubuntu.cloud:server:14.04:amd64']

        releases = trusty['versions'].keys()
        releases.sort()
        latest_release = releases[-1]

        latest_uuid = trusty['versions'][latest_release]['items'][dc]['id']

    else:
        print 'Unable to fetch SimpleStrem feed.'
        sys.exit(1)

    return latest_uuid


def generate_vnc_password():
    s = string.lowercase + string.digits
    password = ''.join(random.sample(s, 10))
    return password
    

def get_ssh_key():
    home = path.expanduser("~")
    ssh_dir = path.join(home, '.ssh')
    ssh_key = False
    id_rsa = path.join(ssh_dir, 'id_rsa.pub')
    id_dsa = path.join(ssh_dir, 'id_dsa.pub')

    if path.isfile(id_rsa):
        print "Found RSA key."
        key_path = id_rsa
        ssh_key = True
    elif path.isfile(id_dsa):
        print "Found DSA key."
        key_path = id_dsa
        ssh_key = True

    if ssh_key:
        f = open(key_path)
        ssh_key = f.read()
        f.close

    return ssh_key


def clone_disk(uuid, name):
    new_disk = drive.clone(uuid, {'name': name})
    get_disk = drive.get(new_disk['uuid'])

    while get_disk['status'] != 'unmounted':
        print "Waiting for clone to finish... (currently '%s')" % get_disk['status']
        sleep(5)
        get_disk = drive.get(new_disk['uuid'])

    print 'Disk clone finished...'
    return get_disk


def wait_for_desired_server_status(uuid, desired_status):
    server_status = server.get(uuid)

    while server_status['status'] != desired_status:
        print "Server currently in state '%s', waiting for '%s'..." % (server_status['status'], desired_status)
        sleep(5)
        server_status = server.get(uuid)

    return server_status


def resize_disk(uuid, new_size):
    new_disk = drive.get(uuid)
    new_disk['size'] = new_size

    drive.update(uuid, new_disk)

    get_disk = drive.get(uuid)
    while get_disk['status'] != 'unmounted':
        print "Waiting for disk resize to finish...(currently '%s')" % get_disk['status']
        sleep(5)
        get_disk = drive.get(uuid)

    print 'Disk resize finished...'
    return get_disk


def create_server(server_name, cpu, mem, disk, vnc_password, cloudinit, template):
    print 'Starting server creation...'
    new_disk = clone_disk(template, server_name)
    resize_disk(new_disk['uuid'], disk)

    server_meta = {
        'name': server_name,
        'cpu': cpu,
        'mem': mem,
        'vnc_password': vnc_password,
        'drives': [{
            'boot_order': 1,
            'dev_channel': '0:0',
            'device': 'virtio',
            'drive': new_disk['uuid']
        }],
        'nics': [{
            'ip_v4_conf': {
                'conf': 'dhcp',
                'ip': None
            },
            'model': 'virtio',
            'vlan': None
        }],
        'meta': {
            'optimize_for': 'linux_vm',
            'description': 'Docker Template',
            'ssh_public_key': '',
            'base64_fields': 'cloudinit-user-data',
            'cloudinit-user-data': base64.b64encode(cloudinit.strip()),
        }
    }

    my_server = server.create(server_meta)
    server_status = wait_for_desired_server_status(my_server['uuid'], 'stopped')

    print 'Starting server...'
    server.start(my_server['uuid'])

    server_status = wait_for_desired_server_status(my_server['uuid'], 'running')
    print "Your server '%s' is now running. You can SSH into the server at '%s'" % (server_name, server_status['nics'][0]['runtime']['ip_v4']['uuid'])

    return my_server