def create_image(self):
        name = self.querystring.get('Name')[0]
        block_devices = []
        instance_ids = instance_ids_from_querystring(self.querystring)
        instance_id = instance_ids[0]
        instance = self.ec2_backend.get_instance(instance_id)

        if "Description" in self.querystring:
            description = self.querystring.get('Description')[0]
        else:
            description = ""

        volume = self.ec2_backend.get_volume(instance.block_device_mapping['/dev/sda1'].volume_id)
        for device in self._get_list_prefix('BlockDeviceMapping'):
            storage = {
                'device_name': device['device_name'],
                'virtual_name': device.get('virtual_name', None),
                'ebs': {
                    'delete': device.get('ebs._delete_on_termination', True),
                    'iops': device.get('ebs._iops', None),
                    'volume_type': device.get('ebs._volume_type', volume.volume_type if device['device_name'] == '/dev/sda1' else 'standard'),
                    'volume_size': device.get('ebs._volume_size', volume.size if device['device_name'] == '/dev/sda1' else 8),
                    'volume_id': None
                }
            }
            block_devices.append(storage)

        image = self.ec2_backend.create_image(instance_id, name, description, block_device_mapping=block_devices)
        template = self.response_template(CREATE_IMAGE_RESPONSE)
        return template.render(image=image)

 def describe_instance_attribute(self):
     # TODO this and modify below should raise IncorrectInstanceState if instance not in stopped state
     attribute = self.querystring.get("Attribute")[0]
     key = camelcase_to_underscores(attribute)
     instance_ids = instance_ids_from_querystring(self.querystring)
     instance_id = instance_ids[0]
     instance, value = ec2_backend.describe_instance_attribute(instance_id, key)
     template = Template(EC2_DESCRIBE_INSTANCE_ATTRIBUTE)
     return template.render(instance=instance, attribute=attribute, value=value)

 def get_console_output(self):
     self.instance_ids = instance_ids_from_querystring(self.querystring)
     instance_id = self.instance_ids[0]
     instance = ec2_backend.get_instance(instance_id)
     if instance:
         template = Template(GET_CONSOLE_OUTPUT_RESULT)
         return template.render(instance=instance)
     else:
         return "", dict(status=404)

 def create_image(self):
     name = self.querystring.get('Name')[0]
     description = self.querystring.get('Description')[0]
     instance_ids = instance_ids_from_querystring(self.querystring)
     instance_id = instance_ids[0]
     image = ec2_backend.create_image(instance_id, name, description)
     if not image:
         return "There is not instance with id {}".format(instance_id), dict(status=404)
     template = Template(CREATE_IMAGE_RESPONSE)
     return template.render(image=image)

    def _security_grp_instance_attribute_handler(self):
        new_security_grp_list = []
        for key, value in self.querystring.items():
            if 'GroupId.' in key:
                new_security_grp_list.append(self.querystring.get(key)[0])

        instance_ids = instance_ids_from_querystring(self.querystring)
        instance_id = instance_ids[0]
        self.ec2_backend.modify_instance_security_groups(instance_id, new_security_grp_list)
        return EC2_MODIFY_INSTANCE_ATTRIBUTE

    def describe_instances(self):
        filter_dict = filters_from_querystring(self.querystring)
        instance_ids = instance_ids_from_querystring(self.querystring)
        if instance_ids:
            reservations = self.ec2_backend.get_reservations_by_instance_ids(instance_ids, filters=filter_dict)
        else:
            reservations = self.ec2_backend.all_reservations(make_copy=True, filters=filter_dict)

        template = self.response_template(EC2_DESCRIBE_INSTANCES)
        return template.render(reservations=reservations)

    def describe_instance_status(self):
        instance_ids = instance_ids_from_querystring(self.querystring)

        if instance_ids:
            instances = self.ec2_backend.get_multi_instances_by_id(instance_ids)
        else:
            instances = self.ec2_backend.all_instances()

        template = Template(EC2_INSTANCE_STATUS)
        return template.render(instances=instances)

    def modify_instance_attribute(self):
        for key, value in self.querystring.iteritems():
            if '.Value' in key:
                break

        value = self.querystring.get(key)[0]
        normalized_attribute = camelcase_to_underscores(key.split(".")[0])
        instance_ids = instance_ids_from_querystring(self.querystring)
        instance_id = instance_ids[0]
        ec2_backend.modify_instance_attribute(instance_id, normalized_attribute, value)
        return EC2_MODIFY_INSTANCE_ATTRIBUTE

 def create_image(self):
     name = self.querystring.get('Name')[0]
     if "Description" in self.querystring:
         description = self.querystring.get('Description')[0]
     else:
         description = ""
     instance_ids = instance_ids_from_querystring(self.querystring)
     instance_id = instance_ids[0]
     image = self.ec2_backend.create_image(instance_id, name, description)
     template = self.response_template(CREATE_IMAGE_RESPONSE)
     return template.render(image=image)

    def describe_instance_status(self):
        instance_ids = instance_ids_from_querystring(self.querystring)
        include_all_instances = optional_from_querystring("IncludeAllInstances", self.querystring) == "true"

        if instance_ids:
            instances = self.ec2_backend.get_multi_instances_by_id(instance_ids)
        elif include_all_instances:
            instances = self.ec2_backend.all_instances()
        else:
            instances = self.ec2_backend.all_running_instances()

        template = self.response_template(EC2_INSTANCE_STATUS)
        return template.render(instances=instances)

    def describe_instances(self):
        instance_ids = instance_ids_from_querystring(self.querystring)
        if instance_ids:
            try:
                reservations = ec2_backend.get_reservations_by_instance_ids(instance_ids)
            except InvalidIdError as exc:
                template = Template(EC2_INVALID_INSTANCE_ID)
                return template.render(instance_id=exc.instance_id), dict(status=400)
        else:
            reservations = ec2_backend.all_reservations(make_copy=True)

        filter_dict = filters_from_querystring(self.querystring)
        reservations = filter_reservations(reservations, filter_dict)

        template = Template(EC2_DESCRIBE_INSTANCES)
        return template.render(reservations=reservations)

    def _dot_value_instance_attribute_handler(self):
        attribute_key = None
        for key, value in self.querystring.items():
            if '.Value' in key:
                attribute_key = key
                break

        if not attribute_key:
            return

        value = self.querystring.get(attribute_key)[0]
        normalized_attribute = camelcase_to_underscores(attribute_key.split(".")[0])
        instance_ids = instance_ids_from_querystring(self.querystring)
        instance_id = instance_ids[0]
        self.ec2_backend.modify_instance_attribute(instance_id, normalized_attribute, value)
        return EC2_MODIFY_INSTANCE_ATTRIBUTE

    def _block_device_mapping_handler(self):
        """
        Handles requests which are generated by code similar to:

            instance.modify_attribute('blockDeviceMapping', {'/dev/sda1': True})

        The querystring contains information similar to:

            BlockDeviceMapping.1.Ebs.DeleteOnTermination : ['true']
            BlockDeviceMapping.1.DeviceName : ['/dev/sda1']

        For now we only support the "BlockDeviceMapping.1.Ebs.DeleteOnTermination"
        configuration, but it should be trivial to add anything else.
        """
        mapping_counter = 1
        mapping_device_name_fmt = 'BlockDeviceMapping.%s.DeviceName'
        mapping_del_on_term_fmt = 'BlockDeviceMapping.%s.Ebs.DeleteOnTermination'
        while True:
            mapping_device_name = mapping_device_name_fmt % mapping_counter
            if mapping_device_name not in self.querystring.keys():
                break

            mapping_del_on_term = mapping_del_on_term_fmt % mapping_counter
            del_on_term_value_str = self.querystring[mapping_del_on_term][0]
            del_on_term_value = True if 'true' == del_on_term_value_str else False
            device_name_value = self.querystring[mapping_device_name][0]

            instance_ids = instance_ids_from_querystring(self.querystring)
            instance_id = instance_ids[0]
            instance = self.ec2_backend.get_instance(instance_id)

            if self.is_not_dryrun('ModifyInstanceAttribute'):
                block_device_type = instance.block_device_mapping[
                    device_name_value]
                block_device_type.delete_on_termination = del_on_term_value

            # +1 for the next device
            mapping_counter += 1

        if mapping_counter > 1:
            return EC2_MODIFY_INSTANCE_ATTRIBUTE

    def describe_instances(self):
        filter_dict = filters_from_querystring(self.querystring)
        instance_ids = instance_ids_from_querystring(self.querystring)
        token = self._get_param("NextToken")
        if instance_ids:
            reservations = self.ec2_backend.get_reservations_by_instance_ids(
                instance_ids, filters=filter_dict)
        else:
            reservations = self.ec2_backend.all_reservations(
                make_copy=True, filters=filter_dict)

        reservation_ids = [reservation.id for reservation in reservations]
        if token:
            start = reservation_ids.index(token) + 1
        else:
            start = 0
        max_results = int(self._get_param('MaxResults', 100))
        reservations_resp = reservations[start:start + max_results]
        next_token = None
        if max_results and len(reservations) > (start + max_results):
            next_token = reservations_resp[-1].id
        template = self.response_template(EC2_DESCRIBE_INSTANCES)
        return template.render(reservations=reservations_resp, next_token=next_token)

 def __init__(self, querystring):
     self.querystring = querystring
     self.instance_ids = instance_ids_from_querystring(querystring)

 def start_instances(self):
     instance_ids = instance_ids_from_querystring(self.querystring)
     instances = ec2_backend.start_instances(instance_ids)
     template = Template(EC2_START_INSTANCES)
     return template.render(instances=instances)

 def terminate_instances(self):
     instance_ids = instance_ids_from_querystring(self.querystring)
     instances = ec2_backend.terminate_instances(instance_ids)
     template = Template(EC2_TERMINATE_INSTANCES)
     return template.render(instances=instances)

 def get_console_output(self):
     self.instance_ids = instance_ids_from_querystring(self.querystring)
     instance_id = self.instance_ids[0]
     instance = self.ec2_backend.get_instance(instance_id)
     template = self.response_template(GET_CONSOLE_OUTPUT_RESULT)
     return template.render(instance=instance)

 def stop_instances(self):
     instance_ids = instance_ids_from_querystring(self.querystring)
     instances = self.ec2_backend.stop_instances(instance_ids)
     template = self.response_template(EC2_STOP_INSTANCES)
     return template.render(instances=instances)

 def reboot_instances(self):
     instance_ids = instance_ids_from_querystring(self.querystring)
     instances = self.ec2_backend.reboot_instances(instance_ids)
     template = self.response_template(EC2_REBOOT_INSTANCES)
     return template.render(instances=instances)