import os
import base64
-
+import string
+import random
from collections import defaultdict
from nova.exception import ImageNotFound
from nova.api.ec2.cloud import CloudController
from sfa.util.xrn import Xrn
from sfa.util.osxrn import OSXrn
from sfa.rspecs.version_manager import VersionManager
-from sfa.openstack.image import Image
+from sfa.openstack.image import ImageManager
from sfa.openstack.security_group import SecurityGroup
from sfa.util.sfalogging import logger
'type': type,
'tags': []})
return sliver
-
+
+
+def ec2_id(id=None, type=None):
+ ec2_id = None
+ if type == 'ovf':
+ type = 'ami'
+ if id and type:
+ ec2_id = CloudController.image_ec2_id(id, type)
+ return ec2_id
+
class OSAggregate:
return rspec.toxml()
def get_slice_nodes(self, slice_xrn):
- image_manager = Image(self.driver)
+ image_manager = ImageManager(self.driver)
name = OSXrn(xrn = slice_xrn).name
instances = self.driver.shell.db.instance_get_all_by_project(name)
rspec_nodes = []
rspec_node['component_manager_id'] = Xrn(self.driver.hrn, 'authority+cm').get_urn()
sliver = instance_to_sliver(instance)
disk_image = image_manager.get_disk_image(instance.image_ref)
- sliver['disk_images'] = [Image.disk_image_to_rspec_object(disk_image)]
+ sliver['disk_images'] = [disk_image.to_rspec_object()]
rspec_node['slivers'] = [sliver]
rspec_nodes.append(rspec_node)
return rspec_nodes
# available sliver/instance/vm types
instances = self.driver.shell.db.instance_type_get_all().values()
# available images
- image_manager = Image(self.driver)
+ image_manager = ImageManager(self.driver)
disk_images = image_manager.get_available_disk_images()
- disk_image_objects = [Image.disk_image_to_rspec_object(image) \
+ disk_image_objects = [image.to_rspec_object() \
for image in disk_images]
rspec_nodes = []
for zone in zones:
Create the slice if it doesn't alredy exist. Create user
accounts that don't already exist
"""
- from nova.exception import ProjectNotFound
- try:
- slice = self.driver.shell.auth_manager.get_project(slicename)
- except ProjectNotFound:
- # assume that the first user is the project manager
- proj_manager = Xrn(users[0]['urn']).get_leaf()
- self.driver.shell.auth_manager.create_project(slicename, proj_manager)
-
+ from nova.exception import ProjectNotFound, UserNotFound
for user in users:
username = Xrn(user['urn']).get_leaf()
try:
self.driver.shell.auth_manager.get_user(username)
except nova.exception.UserNotFound:
self.driver.shell.auth_manager.create_user(username)
- self.verify_user_keys(username, user['keys'], options)
+ self.verify_user_keys(username, user['keys'], options)
+
+ try:
+ slice = self.driver.shell.auth_manager.get_project(slicename)
+ except ProjectNotFound:
+ # assume that the first user is the project manager
+ proj_manager = Xrn(users[0]['urn']).get_leaf()
+ self.driver.shell.auth_manager.create_project(slicename, proj_manager)
def verify_user_keys(self, username, keys, options={}):
"""
instance_type=instance_type,
key_name=key_name,
user_data = user_data,
- security_groups=group_name)
+ security_groups=[group_name])
#placement=zone,
#min_count=min_count,
#max_count=max_count,
except Exception, err:
logger.log_exc(err)
+
def run_instances(self, slicename, rspec, keyname, pubkeys):
"""
# the default image to use for instnaces that dont
# explicitly request an image.
# Just choose the first available image for now.
- image_manager = Image(self.driver)
+ image_manager = ImageManager(self.driver)
available_images = image_manager.get_available_disk_images()
- default_image = available_images[0]
- default_ami_id = CloudController.image_ec2_id(default_image['ami']['id'], 'ami')
- default_aki_id = CloudController.image_ec2_id(default_image['aki']['id'], 'aki')
- default_ari_id = CloudController.image_ec2_id(default_image['ari']['id'], 'ari')
+ default_image_id = None
+ default_aki_id = None
+ default_ari_id = None
+ default_image = available_images[0]
+ default_image_id = ec2_id(default_image.id, default_image.container_format)
+ default_aki_id = ec2_id(default_image.kernel_id, 'aki')
+ default_ari_id = ec2_id(default_image.ramdisk_id, 'ari')
# get requested slivers
rspec = RSpec(rspec)
# Each sliver get's its own security group.
# Keep security group names unique by appending some random
# characters on end.
- group_name = "".join([slicename,
- #instance_type['name'],
- base64.b64encode(os.urandom(6))])
- #group_name = group_name.replace('.', '_')
+ random_name = "".join([random.choice(string.letters+string.digits)
+ for i in xrange(6)])
+ group_name = slicename + random_name
self.create_security_group(group_name, fw_rules)
- ami_id = default_ami_id
+ ami_id = default_image_id
aki_id = default_aki_id
ari_id = default_ari_id
req_image = instance_type.get('disk_images')
req_image_name = req_image[0]['name']
disk_image = image_manager.get_disk_image(name=req_image_name)
if disk_image:
- ami_id = CloudController.image_ec2_id(disk_image['ami']['id'], 'ami')
- aki_id = CloudController.image_ec2_id(disk_image['aki']['id'], 'aki')
- ari_id = CloudController.image_ec2_id(disk_image['ari']['id'], 'ari')
+ ami_id = ec2_id(disk_image.id, disk_image.container_format)
+ aki_id = ec2_id(disk_image.kernel_id, 'aki')
+ ari_id = ec2_id(disk_image.ramdisk_id, 'ari')
# start the instance
self.reserve_instance(image_id=ami_id,
kernel_id=aki_id,
def delete_instances(self, project_name):
instances = self.driver.shell.db.instance_get_all_by_project(project_name)
- security_group_manager = SecurityGroup(self)
+ security_group_manager = SecurityGroup(self.driver)
for instance in instances:
# deleate this instance's security groups
for security_group in instance.security_groups: