Commit 31532fac authored by Bryton Lacquement's avatar Bryton Lacquement Committed by Julien Muchembled

Remove slapos.cloudmgr

parent eaad8c02
......@@ -37,10 +37,8 @@ setup(name=name,
'Flask', # needed by servers
'atomize', # needed by pubsub
'feedparser', # needed by pubsub
'apache_libcloud>=0.4.0', # needed by cloudmgr
'lockfile', # used by equeue
'lxml', # needed for xml parsing
'paramiko', # needed by cloudmgr
'psutil', # needed for playing with processes in portable way
'setuptools', # namespaces
'slapos.core', # as it provides library for slap
......@@ -79,13 +77,6 @@ setup(name=name,
'check-feed-as-promise = slapos.checkfeedaspromise:main',
'check-apachedex-result = slapos.promise.check_apachedex_result:main',
'check-slow-queries-digest-result = slapos.promise.check_slow_queries_digest_result:main',
'clouddestroy = slapos.cloudmgr.destroy:main',
'cloudgetprivatekey = slapos.cloudmgr.getprivatekey:main',
'cloudgetpubliciplist = slapos.cloudmgr.getpubliciplist:main',
'cloudlist = slapos.cloudmgr.list:main',
'cloudmgr = slapos.cloudmgr.cloudmgr:main',
'cloudstart = slapos.cloudmgr.start:main',
'cloudstop = slapos.cloudmgr.stop:main',
'equeue = slapos.equeue:main',
'generatefeed = slapos.generatefeed:main',
'htpasswd = slapos.htpasswd:main',
# See
except ImportError:
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)
from update import update
from destroy import destroy
from start import start
from stop import stop
from list import uuidlist
from getpubliciplist import getpubliciplist
class NodeInterface:
def __init__(self, key, secret, service, location, node_uuid=None,
self.key = key
self.location = location
self.node_uuid = node_uuid
self.ssh_key = ssh_key
self.secret = secret
self.service = service
def update(self, image, size, security_group):
result = update(self.key, self.secret, self.service, self.location,
self.node_uuid, self.ssh_key, image, size, security_group)
self.node_uuid = result['node_uuid']
self.ssh_key = result['ssh_key']
return result
def stop(self):
stop(self.key, self.secret, self.service, self.node_uuid, self.ssh_key)
def start(self):
start(self.key, self.secret, self.service, self.node_uuid)
def destroy(self):
destroy(self.key, self.secret, self.service, self.node_uuid)
def getPublicIpList(self):
return getpubliciplist(self.key, self.secret, self.service, self.node_uuid)
def getNodeUuidList(self):
return uuidlist(self.key, self.secret, self.service)
import sys
import time
from cloudinterface import NodeInterface
class CloudManager:
def __init__(self, configuration_file):
self.configuration_file = configuration_file
def initialiseConfiguration(self):
self.configuration_dict = {}
external_eval = file(self.configuration_file).read()
except IOError:
self.configuration_dict = eval(external_eval)
if type(self.configuration_dict) != type({}):
self.configuration_dict = {}
for k in 'key', 'secret':
if k not in self.configuration_dict:
self.configuration_dict[k] = ''
elif type(self.configuration_dict[k]) != type(''):
self.configuration_dict[k] = ''
if 'node_list' not in self.configuration_dict:
self.configuration_dict['node_list'] = []
if type(self.configuration_dict['node_list']) != type([]):
self.configuration_dict['node_list'] = []
def run(self):
print 'Run begin...'
started = stopped = destroyed = unsupported = 0
self.key = self.configuration_dict['key']
self.secret = self.configuration_dict['secret']
for node in self.configuration_dict['node_list']:
node_object = NodeInterface(self.key, self.secret, node['service'],
node['location'], node['node_uuid'], node['ssh_key'])
if node['requested_state'] == 'started':
print 'Starting %r' % node['node_uuid']
if node_object.start():
started += 1
unsupported += 1
elif node['requested_state'] == 'stopped':
print 'Stopping %r' % node['node_uuid']
if node_object.stop():
stopped += 1
unsupported += 1
elif node['requested_state'] == 'destroyed':
print 'Destroying %r' % node['node_uuid']
if node_object.destroy():
destroyed +=1
unsupported += 1
print 'Unsupported state %r for node %r' % (node['requested_state'],
unsupported += 1
print 'Run finished', dict(started=started, stopped=stopped,
destroyed=destroyed, unsupported=unsupported)
def main():
while True:
from slapos.cloudmgr.lib import getDriverInstance, getNode
from libcloud.types import NodeState
import sys
def destroy(key, secret, service, node_uuid):
driver = getDriverInstance(service, key, secret)
node = getNode(driver, node_uuid)
if node is None:
return False
if node.state in [NodeState.RUNNING, NodeState.REBOOTING, NodeState.PENDING]:
return node.destroy()
return False
def main():
print destroy(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4])
import sys
def getprivatekey(key, secret, service, node_uuid):
"""Fetches private key of node"""
raise NotImplementedError('Cedric implement')
return dict(
ssh_key = ssh_key,
def main():
getprivatekey(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4])
from slapos.cloudmgr.lib import getDriverInstance, getNode
from libcloud.types import NodeState
import time
import sys
def getpubliciplist(key, secret, service, node_uuid):
"""Gets public ip(s), can wait for the first IP to appear"""
public_ip_list = []
for i in range(100):
driver = getDriverInstance(service, key, secret)
node = getNode(driver, node_uuid)
if node.state not in [NodeState.RUNNING, NodeState.REBOOTING,
if node.public_ip[0]:
public_ip_list = node.public_ip
return dict(
public_ip_list = public_ip_list
def main():
print getpubliciplist(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4])
from libcloud.types import Provider
from libcloud.providers import get_driver
import paramiko
import StringIO
driver_list = {
'DUMMY': get_driver(Provider.DUMMY),
'EC2_US_EAST': get_driver(Provider.EC2_US_EAST),
'EC2_US_WEST': get_driver(Provider.EC2_US_WEST),
'EC2_EU_WEST': get_driver(Provider.EC2_EU_WEST),
'RACKSPACE': get_driver(Provider.RACKSPACE),
'SLICEHOST': get_driver(Provider.SLICEHOST),
'GOGRID': get_driver(Provider.GOGRID),
'VPSNET': get_driver(Provider.VPSNET),
'LINODE': get_driver(Provider.LINODE),
'VCLOUD': get_driver(Provider.VCLOUD),
'RIMUHOSTING': get_driver(Provider.RIMUHOSTING),
'ECP': get_driver(Provider.ECP),
'IBM': get_driver(Provider.IBM),
'OPENNEBULA': get_driver(Provider.OPENNEBULA),
'DREAMHOST': get_driver(Provider.DREAMHOST),
def getDriverInstance(driverName, key, secret=None, secure=True, host=None,
return driver_list.get(driverName)(key, secret, secure, host, port)
def getSSHConnection(driver, hostname, private_key):
client = paramiko.SSHClient()
#TODO if exception : try DSSKey
pkey = paramiko.RSAKey.from_private_key(StringIO.StringIO(private_key))
client.connect(hostname=hostname, username='root', pkey=pkey,
return client
def getNode(driver, node_uuid):
node_list = [node for node in driver.list_nodes() if node_uuid in node.uuid]
if len(node_list) == 0:
return None
if len(node_list) != 1:
raise IndexError('Several nodes with the uuid %r exist.' % node_uuid)
return node_list[0]
# Original work by Cedric de Saint Martin, adapted by Lukasz Nowak
import sys
from slapos.cloudmgr.lib import getDriverInstance
def nodelist(key, secret, service):
driver = getDriverInstance(service, key, secret)
node_list = driver.list_nodes()
return node_list
def uuidlist(key, secret, service):
return [q.uuid for q in nodelist(key, secret, service)]
def main():
node_list = nodelist(*sys.argv[1:])
print 'Available nodes (%s):' % len(node_list)
for node in node_list:
print node
from slapos.cloudmgr.lib import getDriverInstance, getNode
import sys
def start(key, secret, service, node_uuid):
"""Starts node"""
driver = getDriverInstance(service, key, secret)
node = getNode(driver, node_uuid)
if node is None:
return False
if node.state in [0, 1]:
return True
elif node.state == 3:
return node.reboot()
return False
return True
def main():
print start(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4])
from getprivatekey import getprivatekey
from libcloud.types import NodeState
from slapos.cloudmgr.lib import getDriverInstance, getSSHConnection, getNode
from paramiko import SSHException
import sys
def stop(key, secret, service, node_uuid, ssh_key=None):
"""Stops node"""
driver = getDriverInstance(service, key, secret)
node = getNode(driver, node_uuid)
# Checks state
if node.state not in [NodeState.RUNNING, NodeState.REBOOTING,
return False
# Good state : connects
if ssh_key is None:
ssh_key = getprivatekey(key, secret, service, node_uuid)
public_ip = node.public_ip[0]
if not public_ip:
raise Exception('Node is started but has no IP.')
ssh = getSSHConnection(driver, public_ip, ssh_key)
print('Stopping instance...')
stdin, stdout, stderr = ssh.exec_command('halt')
except SSHException, e:
print('unable to stop')
raise e
error_log =
if error_log:
raise Exception('''Unable to stop : error log is :
output is : %r''' % (error_log,
return True
def main():
print stop(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4])
from slapos.cloudmgr.lib import getDriverInstance
import sys
import uuid
from libcloud.types import NodeState
def update(key, secret, service, location, node_uuid=None, ssh_key=None,
image=None, size=None, security_group=None):
"""Update or create node"""
if node_uuid is not None:
driver = getDriverInstance(service, key, secret)
found_node_list = [node for node in driver.list_nodes() if node.uuid==node_uuid]
if len(found_node_list) == 0:
# node_uuid relates to not available one, recreate
node_uuid = None
elif len(found_node_list) == 1:
node = found_node_list[0]
if node.state not in [NodeState.RUNNING, NodeState.REBOOTING,
# node_uuid relates to destroyed one, recreate
node_uuid = None
if not node_uuid:
if not image or not size or not location:
raise Exception("Node can not be created because of lacking informations")
# XXX-Cedric : what exception?
# Creates node
return install(key, secret, service, image, size, location, security_group)
return dict(
ssh_key = ssh_key,
node_uuid = node_uuid
def install(key, secret, service, image_id, size_id, location_id,
driver = getDriverInstance(service, key, secret)
# Defines a dict that will be used to create our node(s)
argument_list = dict()
argument_list['image'] = [image for image in driver.list_images() if
image_id in][0]
argument_list['size'] = [size for size in driver.list_sizes() if
size_id in][0]
# We can create uour own images and sizes
#image = NodeImage(id=self.options['image_id'],
# name=self.options['image_name'],
# driver=driver)
#size = NodeSize(self.options['size_id'], self.options['size_name'], None,
# None, None, None, driver=driver)
argument_list['location'] = [location for location in
driver.list_locations() if location_id in][0]
# If we are in ec2 : adding ssh key manually
if 'EC2' in service:
unique_keyname = str(uuid.uuid1())
keypair = driver.ex_create_keypair(unique_keyname)
ssh_key = keypair['keyMaterial']
argument_list['ex_keyname'] = unique_keyname
except Exception, e:
# XX-Cedric : what to do here?
if e.args[0].find("InvalidKeyPair.Duplicate") == -1:
# XXX-Cedric : our unique key was not so unique...Do something
raise e
raise e
# Prepares ssh key deployment and/or postflight script
#if self.options.get('ssh_key') or self.options.get('script'):
# deployment_argument_list = []
# if self.options.get('ssh_key'):
# deployment_argument_list.append(SSHKeyDeployment(
# self.options['ssh_key']))
# if self.options.get('script'):
# script_to_run = ScriptDeployment(self.options['script'])
# deployment_argument_list.append(script_to_run)
# argument_list['deploy'] = MultiStepDeployment(deployment_argument_list)
# If ec2, creates group, adds rules to it.
if 'EC2' in service:
driver.ex_create_security_group(security_group, security_group)
except Exception, e:
if e.args[0].find("InvalidPermission.Duplicate") == -1:
pass #It's okay, don't worry.
argument_list['ex_securitygroup'] = security_group
# Installs node
node = driver.create_node(**argument_list)#deploy_node(**argument_list)
node_uuid = node.uuid
return {'node_uuid': node_uuid, 'ssh_key': ssh_key}
def main():
node_uuid = sys.argv[4]
except IndexError:
node_uuid = None
update(sys.argv[1], sys.argv[2], sys.argv[3], node_uuid)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment