Yasuke/moto
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #102 from andrewgross/feature/block-device-mapping

Browse Source 
[Block Device] Add block device mapping to launch config backend
This commit is contained in:
Steve Pulec 2014-04-29 14:55:10 -04:00
commit f61242feba
3 changed files with 138 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
moto/autoscaling/models.py
View File

@ -1,3 +1,4 @@
from boto.ec2.blockdevicemapping import BlockDeviceType, BlockDeviceMapping
from moto.core import BaseBackend
from moto.ec2 import ec2_backend
@ -29,7 +30,7 @@ class FakeScalingPolicy(object):
class FakeLaunchConfiguration(object):
def __init__(self, name, image_id, key_name, security_groups, user_data,
instance_type, instance_monitoring, instance_profile_name,
spot_price, ebs_optimized, associate_public_ip_address):
spot_price, ebs_optimized, associate_public_ip_address, block_device_mapping_dict):
self.name = name
self.image_id = image_id
self.key_name = key_name
@ -41,6 +42,7 @@ class FakeLaunchConfiguration(object):
self.spot_price = spot_price
self.ebs_optimized = ebs_optimized
self.associate_public_ip_address = associate_public_ip_address
self.block_device_mapping_dict = block_device_mapping_dict
@classmethod
def create_from_cloudformation_json(cls, resource_name, cloudformation_json):
@ -60,6 +62,7 @@ class FakeLaunchConfiguration(object):
spot_price=properties.get("SpotPrice"),
ebs_optimized=properties.get("EbsOptimized"),
associate_public_ip_address=properties.get("AssociatePublicIpAddress"),
block_device_mappings=properties.get("BlockDeviceMapping.member")
)
return config
@ -67,12 +70,35 @@ class FakeLaunchConfiguration(object):
def physical_resource_id(self):
return self.name
@property
def block_device_mappings(self):
if not self.block_device_mapping_dict:
return None
else:
return self._parse_block_device_mappings()
@property
def instance_monitoring_enabled(self):
if self.instance_monitoring:
return 'true'
return 'false'
def _parse_block_device_mappings(self):
block_device_map = BlockDeviceMapping()
for mapping in self.block_device_mapping_dict:
block_type = BlockDeviceType()
mount_point = mapping.get('device_name')
if 'ephemeral' in mapping.get('virtual_name', ''):
block_type.ephemeral_name = mapping.get('virtual_name')
else:
block_type.volume_type = mapping.get('ebs._volume_type')
block_type.snapshot_id = mapping.get('ebs._snapshot_id')
block_type.delete_on_termination = mapping.get('ebs._delete_on_termination')
block_type.size = mapping.get('ebs._volume_size')
block_type.iops = mapping.get('ebs._iops')
block_device_map[mount_point] = block_type
return block_device_map
class FakeAutoScalingGroup(object):
def __init__(self, name, availability_zones, desired_capacity, max_size,
@ -184,7 +210,7 @@ class AutoScalingBackend(BaseBackend):
def create_launch_configuration(self, name, image_id, key_name,
security_groups, user_data, instance_type,
instance_monitoring, instance_profile_name,
spot_price, ebs_optimized, associate_public_ip_address):
spot_price, ebs_optimized, associate_public_ip_address, block_device_mappings):
launch_configuration = FakeLaunchConfiguration(
name=name,
image_id=image_id,
@ -197,6 +223,7 @@ class AutoScalingBackend(BaseBackend):
spot_price=spot_price,
ebs_optimized=ebs_optimized,
associate_public_ip_address=associate_public_ip_address,
block_device_mapping_dict=block_device_mappings,
)
self.launch_configurations[name] = launch_configuration
return launch_configuration

44
moto/autoscaling/responses.py
View File

@ -1,6 +1,7 @@
from jinja2 import Template
from moto.core.responses import BaseResponse
from moto.core.utils import camelcase_to_underscores
from .models import autoscaling_backend
@ -17,6 +18,21 @@ class AutoScalingResponse(BaseResponse):
def _get_multi_param(self, param_prefix):
return [value[0] for key, value in self.querystring.items() if key.startswith(param_prefix)]
def _get_list_prefix(self, param_prefix):
results = []
param_index = 1
while True:
index_prefix = "{0}.{1}.".format(param_prefix, param_index)
new_items = {}
for key, value in self.querystring.items():
if key.startswith(index_prefix):
new_items[camelcase_to_underscores(key.replace(index_prefix, ""))] = value[0]
if not new_items:
break
results.append(new_items)
param_index += 1
return results
def create_launch_configuration(self):
instance_monitoring_string = self._get_param('InstanceMonitoring.Enabled')
if instance_monitoring_string == 'true':
@ -35,6 +51,7 @@ class AutoScalingResponse(BaseResponse):
spot_price=self._get_param('SpotPrice'),
ebs_optimized=self._get_param('EbsOptimized'),
associate_public_ip_address=self._get_param("AssociatePublicIpAddress"),
block_device_mappings=self._get_list_prefix('BlockDeviceMappings.member')
)
template = Template(CREATE_LAUNCH_CONFIGURATION_TEMPLATE)
return template.render()
@ -173,7 +190,34 @@ DESCRIBE_LAUNCH_CONFIGURATIONS_TEMPLATE = """<DescribeLaunchConfigurationsRespon
<InstanceType>m1.small</InstanceType>
<LaunchConfigurationARN>arn:aws:autoscaling:us-east-1:803981987763:launchConfiguration:
9dbbbf87-6141-428a-a409-0752edbe6cad:launchConfigurationName/my-test-lc</LaunchConfigurationARN>
{% if launch_configuration.block_device_mappings %}
<BlockDeviceMappings>
{% for mount_point, mapping in launch_configuration.block_device_mappings.iteritems() %}
<member>
<DeviceName>{{ mount_point }}</DeviceName>
{% if mapping.ephemeral_name %}
<VirtualName>{{ mapping.ephemeral_name }}</VirtualName>
{% else %}
<Ebs>
{% if mapping.snapshot_id %}
<SnapshotId>{{ mapping.snapshot_id }}</SnapshotId>
{% endif %}
{% if mapping.size %}
<VolumeSize>{{ mapping.size }}</VolumeSize>
{% endif %}
{% if mapping.iops %}
<Iops>{{ mapping.iops }}</Iops>
{% endif %}
<DeleteOnTermination>{{ mapping.delete_on_termination }}</DeleteOnTermination>
<VolumeType>{{ mapping.volume_type }}</VolumeType>
</Ebs>
{% endif %}
</member>
{% endfor %}
</BlockDeviceMappings>
{% else %}
<BlockDeviceMappings/>
{% endif %}
<ImageId>{{ launch_configuration.image_id }}</ImageId>
{% if launch_configuration.key_name %}
<KeyName>{{ launch_configuration.key_name }}</KeyName>

64
tests/test_autoscaling/test_launch_configurations.py
View File

@ -1,5 +1,6 @@
import boto
from boto.ec2.autoscale.launchconfig import LaunchConfiguration
from boto.ec2.blockdevicemapping import BlockDeviceType, BlockDeviceMapping
import sure # noqa
@ -35,6 +36,69 @@ def test_create_launch_configuration():
launch_config.spot_price.should.equal(0.1)
@requires_boto_gte("2.27.0")
@mock_autoscaling
def test_create_launch_configuration_with_block_device_mappings():
block_device_mapping = BlockDeviceMapping()
ephemeral_drive = BlockDeviceType()
ephemeral_drive.ephemeral_name = 'ephemeral0'
block_device_mapping['/dev/xvdb'] = ephemeral_drive
snapshot_drive = BlockDeviceType()
snapshot_drive.snapshot_id = "snap-1234abcd"
snapshot_drive.volume_type = "standard"
block_device_mapping['/dev/xvdp'] = snapshot_drive
ebs_drive = BlockDeviceType()
ebs_drive.volume_type = "io1"
ebs_drive.size = 100
ebs_drive.iops = 1000
ebs_drive.delete_on_termination = False
block_device_mapping['/dev/xvdh'] = ebs_drive
conn = boto.connect_autoscale(use_block_device_types=True)
config = LaunchConfiguration(
name='tester',
image_id='ami-abcd1234',
instance_type='m1.small',
key_name='the_keys',
security_groups=["default", "default2"],
user_data="This is some user_data",
instance_monitoring=True,
instance_profile_name='arn:aws:iam::123456789012:instance-profile/testing',
spot_price=0.1,
block_device_mappings=[block_device_mapping]
)
conn.create_launch_configuration(config)
launch_config = conn.get_all_launch_configurations()[0]
launch_config.name.should.equal('tester')
launch_config.image_id.should.equal('ami-abcd1234')
launch_config.instance_type.should.equal('m1.small')
launch_config.key_name.should.equal('the_keys')
set(launch_config.security_groups).should.equal(set(['default', 'default2']))
launch_config.user_data.should.equal("This is some user_data")
launch_config.instance_monitoring.enabled.should.equal('true')
launch_config.instance_profile_name.should.equal('arn:aws:iam::123456789012:instance-profile/testing')
launch_config.spot_price.should.equal(0.1)
len(launch_config.block_device_mappings).should.equal(3)
returned_mapping = launch_config.block_device_mappings
set(returned_mapping.keys()).should.equal(set(['/dev/xvdb', '/dev/xvdp', '/dev/xvdh']))
returned_mapping['/dev/xvdh'].iops.should.equal(1000)
returned_mapping['/dev/xvdh'].size.should.equal(100)
returned_mapping['/dev/xvdh'].volume_type.should.equal("io1")
returned_mapping['/dev/xvdh'].delete_on_termination.should.be.false
returned_mapping['/dev/xvdp'].snapshot_id.should.equal("snap-1234abcd")
returned_mapping['/dev/xvdp'].volume_type.should.equal("standard")
returned_mapping['/dev/xvdb'].ephemeral_name.should.equal('ephemeral0')
@requires_boto_gte("2.12")
@mock_autoscaling
def test_create_launch_configuration_for_2_12():