def _start_image_on_cloudstack(self, user_info, node_instance, vm_name):
instance_name = self.format_instance_name(vm_name)
instance_type = node_instance.get_instance_type()
ip_type = node_instance.get_network_type()
keypair = None
contextualization_script = None
if not node_instance.is_windows():
keypair = user_info.get_keypair_name()
contextualization_script = self._get_bootstrap_script_if_not_build_image(node_instance)
security_groups = node_instance.get_security_groups()
security_groups = (len(security_groups) > 0) and security_groups or None
try:
size = [i for i in self.sizes if i.name == instance_type][0]
except IndexError:
raise Exceptions.ParameterNotFoundException("Couldn't find the specified instance type: %s" % instance_type)
image = self._get_image(node_instance)
if node_instance.is_windows():
instance = self.libcloud_driver.create_node(
name=instance_name,
size=size,
image=image,
location=self.zone,
ex_security_groups=security_groups)
else:
instance = self.libcloud_driver.create_node(
name=instance_name,
size=size,
image=image,
location=self.zone,
ex_keyname=keypair,
ex_userdata=contextualization_script,
ex_security_groups=security_groups)
ip = self._get_instance_ip_address(instance, ip_type)
if not ip:
raise Exceptions.ExecutionException("Couldn't find a '%s' IP" % ip_type)
vm = dict(instance=instance,
ip=ip,
id=instance.id)
return vm
def _get_security_groups_for_node_instance(self, node_instance):
security_groups = []
security_groups_not_found = []
for sg_name in node_instance.get_security_groups():
if not sg_name:
continue
sgs = [sg for sg in self.security_groups if sg.name == sg_name.strip()]
if len(sgs) < 1:
security_groups_not_found.append(sg_name)
else:
security_groups.append(sgs[0])
if security_groups_not_found:
raise Exceptions.ParameterNotFoundException("Couldn't find the following security groups: %s"
% ', '.join(security_groups_not_found))
return security_groups
def _start_image(self, userInfo, nodeInstance, vm_name):
"""
:type userInfo: slipstream.UserInfo.UserInfo
:type nodeInstance: slipstream.NodeInstance.NodeInstance
:param vm_name: string
:return: :raise Exception:
"""
# userInfo = {
# "okeanos.username": "******",
# "okeanos.max.iaas.workers": "20",
# "okeanos.quota.vm": "",
# "okeanos.service.name": "cyclades_compute",
# "General.On Error Run Forever": "true",
# "General.Timeout": "30",
# "General.On Success Run Forever": "true",
# "General.orchestrator.publicsshkey": "ssh-rsa LOCALKEY root@snf-000000\n",
# "okeanos.orchestrator.instance.type": "C2R2048D10ext_vlmc",
# "okeanos.orchestrator.imageid": "fe31fced-a3cf-49c6-b43b-f58f5235ba45",
# "User.email": "*****@*****.**",
# "General.default.cloud.service": "okeanos",
# "okeanos.endpoint": "https://accounts.okeanos.grnet.gr/identity/v2.0",
# "User.lastName": "User",
# "okeanos.update.clienturl": "https://SlipStreamServer/downloads/okeanoslibs.tar.gz",
# "User.firstName": "Super",
# "okeanos.service.region": "default",
# "General.ssh.public.key": "ssh-rsa SlipStreamServerUIUserSSHKey\n",
# "okeanos.service.type": "compute",
# "General.Verbosity Level": "3",
# "okeanos.password": "******"
#}
# nodeInstance = NodeInstance({
# "image.parentUri": "module/P5",
# "image.shortName": "B3",
# "image.logoLink": "",
# "abort": None,
# "image.deleted": "false",
# "image.category": "Image",
# "image.class": "com.sixsq.slipstream.persistence.ImageModule",
# "image.version": "8",
# "okeanos.security.groups": "default",
# "okeanos.instance.type": "C2R2048D10ext_vlmc",
# "extra.disk.volatile": None,
# "image.platform": "ubuntu",
# "network": "Public",
# "image.moduleReferenceUri": "module/P5/I5",
# "hostname": None,
# "image.lastModified": "2014-09-20 17:56:10.860 EEST",
# "is.orchestrator": "false",
# "url.service": None,
# "statecustom": None,
# "image.isBase": "false",
# "complete": "false",
# "image.resourceUri": "module/P5/B3/8",
# "image.id": "fe31fced-a3cf-49c6-b43b-f58f5235ba45",
# "image.loginUser": "******",
# "image.isLatestVersion": "true",
# "scale.state": "creating",
# "image.packages": [],
# "image.name": "P5/B3",
# "name": "machine",
# "instanceid": None,
# "cloudservice": "okeanos",
# "image.recipe": "#!/bin/sh\n\necho BuildImage > /root/BuildImage.txt\n\n",
# "url.ssh": None,
# "image.creation": "2014-09-20 17:56:10.822 EEST",
# "image.prerecipe": "",
# "vmstate": "Unknown",
# "image.description": ""
#})
self.log()
self.log("userInfo = %s" % userInfo)
self.log("nodeInstance = %s" % nodeInstance)
self.log("vm_name = %s" % vm_name)
initScriptData = self._get_init_script(nodeInstance)
self.log("initScriptData = %s" % initScriptData)
imageId = nodeInstance.get_image_id()
flavorIdOrName = nodeInstance.get_instance_type()
sshPubKey = userInfo.get_public_keys()
initScriptPath = "/root/okeanosNodeInitScript"
if initScriptData is None:
initScriptPathAndData = None
else:
initScriptPathAndData = (initScriptPath, initScriptData)
remoteUsername = "******" # TODO make it configurable
localPubKeyData = loadPubRsaKeyData()
runInitScriptSynchronously = False # TODO make it configurable
if flavorIdOrName is None:
raise Exceptions.ParameterNotFoundException("Couldn't find the specified flavor: %s" % flavorIdOrName)
if imageId is None:
raise Exceptions.ParameterNotFoundException("Couldn't find the specified image: %s" % imageId)
# We need to run the initScript manually, since ~Okeanos does not support it.
# Let's wait until we have SSH and then run the script.
# TODO: Provide network type.
nodeDetails, scriptResults = self.okeanosClient.createNodeAndWait(
vm_name, flavorIdOrName, imageId,
sshPubKey,
initScriptPathAndData=initScriptPathAndData,
remoteUsername=remoteUsername,
localPubKeyData=localPubKeyData,
runInitScriptSynchronously=runInitScriptSynchronously,
projectId=self.okeanosProjectId)
scriptExitCode, scriptStdoutLines, scriptStderrLines = scriptResults
hostname = nodeDetails.ipv4s[0]
for line in scriptStdoutLines:
LOG("[%s] #STDOUT# %s" % (hostname, line))
for line in scriptStderrLines:
LOG("[%s] #STDERR# %s" % (hostname, line))
vm = dict(
networkType='Public', # self.getCloudParameters(image_info)['network']
instance=nodeDetails,
ip='',
id=nodeDetails.id
)
return vm
def _start_image_on_openstack(self, user_info, node_instance, vm_name):
image_id = node_instance.get_image_id()
instance_type = node_instance.get_instance_type()
keypair = user_info.get_keypair_name()
security_groups = self._get_security_groups_for_node_instance(node_instance)
flavor = searchInObjectList(self.flavors, 'name', instance_type)
image = searchInObjectList(self.images, 'id', image_id)
contextualization_script = self._get_bootstrap_script_if_not_build_image(node_instance)
use_floating_ips = self._is_floating_ip(user_info)
if flavor is None:
raise Exceptions.ParameterNotFoundException("Couldn't find the specified flavor: %s" % instance_type)
if image is None:
raise Exceptions.ParameterNotFoundException("Couldn't find the specified image: %s" % image_id)
# extract mappings for Public and Private networks from the connector instance
network = None
network_type = node_instance.get_network_type()
if network_type == 'Public' and not use_floating_ips:
network_name = user_info.get_public_network_name()
network = searchInObjectList(self.networks, 'name', network_name)
elif network_type == 'Private' or (network_type == 'Public' and use_floating_ips):
network_name = user_info.get_private_network_name()
network = searchInObjectList(self.networks, 'name', network_name)
kwargs = {"name": vm_name,
"size": flavor,
"image": image,
"ex_keyname": keypair,
"ex_userdata": contextualization_script,
"ex_security_groups": security_groups}
if network is not None:
kwargs["networks"] = [network]
kwargs['ex_metadata'] = {}
floating_ip = None
ip = None
if use_floating_ips and network_type == 'Public':
ip_pool = user_info.get_public_network_name() or None
floating_ip = self._thread_local.driver.ex_create_floating_ip(ip_pool)
ip = floating_ip.ip_address
kwargs['ex_metadata'].update({'floating_ip': floating_ip.id})
additional_disk = None
if node_instance.get_volatile_extra_disk_size():
additional_disk = self._thread_local.driver.create_volume(node_instance.get_volatile_extra_disk_size(), \
'ss-disk-%i' % int(time.time()), \
location=self._get_service_name(user_info))
kwargs['ex_metadata'].update({'additional_disk_id': additional_disk.id})
try:
instance = self._thread_local.driver.create_node(**kwargs)
if floating_ip or additional_disk:
self._wait_instance_in_running_state(instance.id)
if floating_ip:
self._thread_local.driver.ex_attach_floating_ip_to_node(instance, floating_ip)
if additional_disk:
self._thread_local.driver.attach_volume(instance, additional_disk, device='/dev/vdb')
except:
if floating_ip:
self._delete_floating_ip(floating_ip)
if additional_disk:
self._thread_local.driver.destroy_volume(additional_disk)
raise
vm = dict(networkType=node_instance.get_network_type(),
instance=instance,
ip=ip or '',
id=instance.id,
strict_ip_retrival=network is None)
return vm
def _get_image(self, node_instance):
image_id = node_instance.get_image_id()
try:
return [i for i in self.images if i.id == image_id][0]
except IndexError:
raise Exceptions.ParameterNotFoundException("Couldn't find the specified image: %s" % image_id)
def _get_zone(self, user_info):
zone_name = user_info.get_cloud('zone', '')
try:
return [i for i in self.zones if i.name.lower() == zone_name.lower()][0]
except IndexError:
raise Exceptions.ParameterNotFoundException("Couldn't find the specified zone: %s" % zone_name)
def _start_image_on_cloudstack(self, user_info, node_instance, vm_name):
image_id = node_instance.get_image_id()
instance_name = self.format_instance_name(vm_name)
instance_type = node_instance.get_instance_type()
ip_type = node_instance.get_network_type()
keypair = None
contextualization_script = None
if not node_instance.is_windows():
keypair = user_info.get_keypair_name()
contextualization_script = self.is_build_image(
) and '' or self._get_bootstrap_script(node_instance)
security_groups = node_instance.get_security_groups()
security_groups = (len(security_groups) >
0) and security_groups or None
_networks = node_instance.get_networks()
try:
networks = [[i for i in self.networks if i.name == x.strip()][0]
for x in _networks if x]
except IndexError:
networks = []
if not networks:
raise Exceptions.ParameterNotFoundException(
"Couldn't find one or more of the specified networks: %s" %
_networks)
try:
size = [i for i in self.sizes if i.name == instance_type][0]
except IndexError:
raise Exceptions.ParameterNotFoundException(
"Couldn't find the specified instance type: %s" %
instance_type)
try:
image = [i for i in self.images if i.id == image_id][0]
except IndexError:
raise Exceptions.ParameterNotFoundException(
"Couldn't find the specified image: %s" % image_id)
if node_instance.is_windows():
instance = self._thread_local.driver.create_node(
name=instance_name,
size=size,
image=image,
ex_security_groups=security_groups,
networks=networks)
else:
instance = self._thread_local.driver.create_node(
name=instance_name,
size=size,
image=image,
ex_keyname=keypair,
ex_userdata=contextualization_script,
ex_security_groups=security_groups,
networks=networks)
ip = self._get_instance_ip_address(instance, ip_type)
if not ip:
raise Exceptions.ExecutionException("Couldn't find a '%s' IP" %
ip_type)
vm = dict(instance=instance, ip=ip, id=instance.id)
return vm
