def test_simple(self):
import datetime
from amitools.tools.ami_describe_ancestors import (
get_args,
main,
CHAIN_SUCCESS,
CHAIN_NO_AMI,
)
from amitools.util import (
calc_tags,
tag_image,
)
# Start by creating test AMIs
from amitools.util import random_name
from amitools.watch import EC2ImageWatcher
self.log('Creating test AMIs')
now = datetime.datetime.utcnow()
# child AMI
child_image_id = self.conn.create_image(self.instance.id, random_name(), no_reboot=True)
self.log('Test child AMI id will be {} - setting up tags'.format(child_image_id))
child_tags = calc_tags(
self.instance.image_id,
self.instance.id,
'us-east-1',
now - datetime.timedelta(seconds=5),
)
child_watcher = EC2ImageWatcher(child_image_id, self.conn)
child_watcher.waiton_exists()
tag_image(self.conn, child_image_id, child_tags)
self.log('Waiting for child AMI {} to be available'.format(child_image_id))
child_watcher.waiton('available')
# grandchild AMI
grandchild_image_id = self.conn.create_image(self.instance.id, random_name(), no_reboot=True)
self.log('Grandchild AMI ID will be {} - setting up tags'.format(grandchild_image_id))
grandchild_tags = calc_tags(
child_image_id,
'i-12345678',
'us-east-1',
now,
)
grandchild_watcher = EC2ImageWatcher(grandchild_image_id, self.conn)
grandchild_watcher.waiton_exists()
tag_image(self.conn, grandchild_image_id, grandchild_tags)
self.log('Waiting for grandchild AMI {} to be available'.format(grandchild_image_id))
grandchild_watcher.waiton('available')
child_image = self.get_image(child_image_id)
grandchild_image = self.get_image(grandchild_image_id)
# now ready to run tests
self.log('Test AMIs available, proceeding with test')
args = get_args([
grandchild_image_id,
])
result = main(args)
self.assertEqual(CHAIN_SUCCESS, result['exit_code'])
expected_chain = [
grandchild_image_id,
child_image_id,
self.instance.image_id,
]
self.assertSequenceEqual(expected_chain, result['chain'])
def test_simple(self):
# Start by creating our own AMI, which we'll do by imaging the dev instance
from amitools.util import random_name
from amitools.watch import EC2ImageWatcher
self.log('Creating test AMI')
image_id = self.conn.create_image(self.instance.id, random_name(), no_reboot=True)
self.log('Test AMI id will be %s - waiting until it is available' % image_id)
EC2ImageWatcher(image_id, self.conn).waiton('available')
image = self.conn.get_all_images([image_id])[0]
self.log('Test AMI %s available, proceeding with test ' % image_id)
# now we have our own unique image with no tags
self.assertEqual(0, len(image.tags), str(image.tags))
from amitools.tools.ami_tag_image import (
get_args,
main,
)
args = get_args([
'--source-image',
'ami-12341234',
'--source-instance',
'i-12341234',
'--source-region',
'us-east-1',
'--create-timestamp',
'1369723137',
image_id,
])
result = main(args)
# check result
new_image = self.conn.get_all_images([image_id])[0]
self.assertEqual('ami-12341234', new_image.tags['source_image'])
self.assertEqual('i-12341234', new_image.tags['source_instance'])
self.assertEqual('1369723137', new_image.tags['create_timestamp'])
self.assertEqual('us-east-1', new_image.tags['source_region'])
def test_simple(self):
# Start by creating our own AMI, which we'll do by imaging the dev instance
from amitools.util import random_name
from amitools.watch import EC2ImageWatcher
self.log('Creating test AMI')
image_id = self.conn.create_image(self.instance.id, random_name(), no_reboot=True)
self.log('Test AMI id will be %s - waiting until it is available' % image_id)
EC2ImageWatcher(image_id, self.conn).waiton('available')
image = self.conn.get_all_images([image_id])[0]
self.log('Test AMI %s available, proceeding with test ' % image_id)
# now we have our own unique image with no tags
self.assertEqual(0, len(image.tags), str(image.tags))
from amitools.tools.ami_tag_image import (
get_args,
main,
)
args = get_args([
'--source-image',
'ami-12341234',
'--source-instance',
'i-12341234',
'--create-timestamp',
'1369723137',
image_id,
])
result = main(args)
# check result
new_image = self.conn.get_all_images([image_id])[0]
self.assertEqual('ami-12341234', new_image.tags['source_image'])
self.assertEqual('i-12341234', new_image.tags['source_instance'])
self.assertEqual('1369723137', new_image.tags['create_timestamp'])
def test_simple(self):
import datetime
from amitools.tools.ami_describe_ancestors import get_args, main, CHAIN_SUCCESS, CHAIN_NO_AMI
from amitools.util import calc_tags, tag_image
# Start by creating test AMIs
from amitools.util import random_name
from amitools.watch import EC2ImageWatcher
self.log("Creating test AMIs")
now = datetime.datetime.utcnow()
# child AMI
child_image_id = self.conn.create_image(self.instance.id, random_name(), no_reboot=True)
self.log("Test child AMI id will be {} - setting up tags".format(child_image_id))
child_tags = calc_tags(self.instance.image_id, self.instance.id, now - datetime.timedelta(seconds=5))
child_watcher = EC2ImageWatcher(child_image_id, self.conn)
child_watcher.waiton_exists()
tag_image(self.conn, child_image_id, child_tags)
self.log("Waiting for child AMI {} to be available".format(child_image_id))
child_watcher.waiton("available")
# grandchild AMI
grandchild_image_id = self.conn.create_image(self.instance.id, random_name(), no_reboot=True)
self.log("Grandchild AMI ID will be {} - setting up tags".format(grandchild_image_id))
grandchild_tags = calc_tags(child_image_id, "i-12345678", now)
grandchild_watcher = EC2ImageWatcher(grandchild_image_id, self.conn)
grandchild_watcher.waiton_exists()
tag_image(self.conn, grandchild_image_id, grandchild_tags)
self.log("Waiting for grandchild AMI {} to be available".format(grandchild_image_id))
grandchild_watcher.waiton("available")
child_image = self.get_image(child_image_id)
grandchild_image = self.get_image(grandchild_image_id)
# now ready to run tests
self.log("Test AMIs available, proceeding with test")
args = get_args([grandchild_image_id])
result = main(args)
self.assertEqual(CHAIN_SUCCESS, result["exit_code"])
expected_chain = [grandchild_image_id, child_image_id, self.instance.image_id]
self.assertSequenceEqual(expected_chain, result["chain"])
def main(args):
import datetime
import time
from amitools.watch import EC2ImageWatcher
from amitools.util import (
get_instance,
random_name,
)
from amitools import ec2connect
from amitools.util import (
calc_tags,
tag_image,
)
if args.name is None:
args.name = random_name(args.random_name_prefix)
conn = ec2connect(args.region)
image_id = conn.create_image(
args.instance_id,
args.name,
description=args.description,
no_reboot = args.no_reboot,
)
image_watcher = EC2ImageWatcher(image_id, conn)
image_watcher.waiton_exists()
# AMI image creation started. While that's cooking, set up tags
image = image_watcher.resource
source_instance = get_instance(conn, args.instance_id)
source_region = source_instance.region.name
tags = calc_tags(
source_instance.image_id,
args.instance_id,
source_region,
datetime.datetime.utcnow(),
)
tag_image(
conn,
image.id,
tags,
)
return {
'image_id' : image_id,
}
def main(args):
import datetime
import time
from amitools.watch import EC2ImageWatcher
from amitools.util import (
get_instance,
random_name,
)
from amitools import ec2connect
from amitools.util import (
calc_tags,
tag_image,
)
if args.name is None:
args.name = random_name(args.random_name_prefix)
conn = ec2connect(args.region)
image_id = conn.create_image(
args.instance_id,
args.name,
description=args.description,
no_reboot=args.no_reboot,
)
image_watcher = EC2ImageWatcher(image_id, conn)
image_watcher.waiton_exists()
# AMI image creation started. While that's cooking, set up tags
image = image_watcher.resource
source_instance = get_instance(conn, args.instance_id)
source_region = source_instance.region.name
tags = calc_tags(
source_instance.image_id,
args.instance_id,
source_region,
datetime.datetime.utcnow(),
)
tag_image(
conn,
image.id,
tags,
)
return {
'image_id': image_id,
}
def test_simple(self):
import datetime
from amitools.tools.ami_describe_ancestors import (
get_args,
main,
CHAIN_SUCCESS,
CHAIN_NO_AMI,
)
from amitools.util import (
calc_tags,
tag_image,
)
# Start by creating test AMIs
from amitools.util import random_name
from amitools.watch import EC2ImageWatcher
self.log('Creating test AMIs')
now = datetime.datetime.utcnow()
# child AMI
child_image_id = self.conn.create_image(self.instance.id,
random_name(),
no_reboot=True)
self.log('Test child AMI id will be {} - setting up tags'.format(
child_image_id))
child_tags = calc_tags(
self.instance.image_id,
self.instance.id,
now - datetime.timedelta(seconds=5),
)
child_watcher = EC2ImageWatcher(child_image_id, self.conn)
child_watcher.waiton_exists()
tag_image(self.conn, child_image_id, child_tags)
self.log(
'Waiting for child AMI {} to be available'.format(child_image_id))
child_watcher.waiton('available')
# grandchild AMI
grandchild_image_id = self.conn.create_image(self.instance.id,
random_name(),
no_reboot=True)
self.log('Grandchild AMI ID will be {} - setting up tags'.format(
grandchild_image_id))
grandchild_tags = calc_tags(
child_image_id,
'i-12345678',
now,
)
grandchild_watcher = EC2ImageWatcher(grandchild_image_id, self.conn)
grandchild_watcher.waiton_exists()
tag_image(self.conn, grandchild_image_id, grandchild_tags)
self.log('Waiting for grandchild AMI {} to be available'.format(
grandchild_image_id))
grandchild_watcher.waiton('available')
child_image = self.get_image(child_image_id)
grandchild_image = self.get_image(grandchild_image_id)
# now ready to run tests
self.log('Test AMIs available, proceeding with test')
args = get_args([
grandchild_image_id,
])
result = main(args)
self.assertEqual(CHAIN_SUCCESS, result['exit_code'])
expected_chain = [
grandchild_image_id,
child_image_id,
self.instance.image_id,
]
self.assertSequenceEqual(expected_chain, result['chain'])
