+
+
+ def create_security_group(self, slicename, fw_rules=[]):
+ # use default group by default
+ group_name = 'default'
+ if isinstance(fw_rules, list) and fw_rules:
+ # Each sliver get's its own security group.
+ # Keep security group names unique by appending some random
+ # characters on end.
+ random_name = "".join([random.choice(string.letters+string.digits)
+ for i in xrange(6)])
+ group_name = slicename + random_name
+ security_group = SecurityGroup(self.driver)
+ security_group.create_security_group(group_name)
+ for rule in fw_rules:
+ security_group.add_rule_to_group(group_name,
+ protocol = rule.get('protocol'),
+ cidr_ip = rule.get('cidr_ip'),
+ port_range = rule.get('port_range'),
+ icmp_type_code = rule.get('icmp_type_code'))
+ return group_name
+
+ def add_rule_to_security_group(self, group_name, **kwds):
+ security_group = SecurityGroup(self.driver)
+ security_group.add_rule_to_group(group_name=group_name,
+ protocol=kwds.get('protocol'),
+ cidr_ip =kwds.get('cidr_ip'),
+ icmp_type_code = kwds.get('icmp_type_code'))
+
+
+ def reserve_instance(self, image_id, kernel_id, ramdisk_id, \
+ instance_type, key_name, user_data, group_name):
+ conn = self.driver.euca_shell.get_euca_connection()
+ logger.info('Reserving an instance: image: %s, kernel: ' \
+ '%s, ramdisk: %s, type: %s, key: %s' % \
+ (image_id, kernel_id, ramdisk_id,
+ instance_type, key_name))
+ try:
+ reservation = conn.run_instances(image_id=image_id,
+ kernel_id=kernel_id,
+ ramdisk_id=ramdisk_id,
+ instance_type=instance_type,
+ key_name=key_name,
+ user_data = user_data,
+ 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):
+ """
+ Create the security groups and instances.
+ """
+ # the default image to use for instnaces that dont
+ # explicitly request an image.
+ # Just choose the first available image for now.
+ image_manager = ImageManager(self.driver)
+ available_images = image_manager.get_available_disk_images()
+ 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)
+ user_data = "\n".join(pubkeys)
+ requested_instances = defaultdict(list)
+ # iterate over clouds/zones/nodes
+ for node in rspec.version.get_nodes_with_slivers():
+ instance_types = node.get('slivers', [])
+ if isinstance(instance_types, list):
+ # iterate over sliver/instance types
+ for instance_type in instance_types:
+ fw_rules = instance_type.get('fw_rules', [])
+ group_name = self.create_security_group(slicename, fw_rules)
+ ami_id = default_image_id
+ aki_id = default_aki_id
+ ari_id = default_ari_id
+ req_image = instance_type.get('disk_image')
+ if req_image and isinstance(req_image, list):
+ req_image_name = req_image[0]['name']
+ disk_image = image_manager.get_disk_image(name=req_image_name)
+ if disk_image:
+ 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,
+ ramdisk_id=ari_id,
+ instance_type=instance_type['name'],
+ key_name=keyname,
+ user_data=user_data,
+ group_name=group_name)
+
+
+ def delete_instances(self, project_name):
+ instances = self.driver.shell.db.instance_get_all_by_project(project_name)
+ security_group_manager = SecurityGroup(self.driver)
+ for instance in instances:
+ # deleate this instance's security groups
+ for security_group in instance.security_groups:
+ # dont delete the default security group
+ if security_group.name != 'default':
+ security_group_manager.delete_security_group(security_group.name)
+ # destroy instance
+ self.driver.shell.db.instance_destroy(instance.id)
+ return 1
+
+ def stop_instances(self, project_name):
+ instances = self.driver.shell.db.instance_get_all_by_project(project_name)
+ for instance in instances:
+ self.driver.shell.db.instance_stop(instance.id)
+ return 1
+
+ def update_instances(self, project_name):
+ pass