def test_cataloging_error_hostname_reuse(self):
"""Ensures an instance is marked cataloged on HOSTNAME_REUSE."""
def add_machine(*args, **kwargs):
return {'error': 'HOSTNAME_REUSE'}
def send_machine_event(*args, **kwargs):
pass
self.mock(catalog.machine_provider, 'add_machine', add_machine)
self.mock(catalog.metrics, 'send_machine_event', send_machine_event)
key = instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
)
key = models.Instance(
key=key,
instance_group_manager=instances.get_instance_group_manager_key(
key),
).put()
models.InstanceGroupManager(
key=instances.get_instance_group_manager_key(key), ).put()
models.InstanceTemplateRevision(
key=instances.get_instance_group_manager_key(key).parent(),
service_accounts=[
models.ServiceAccount(name='service-account'),
],
).put()
catalog.catalog(key)
self.failUnless(key.get().cataloged)
def test_creates(self):
"""Ensures an instance template is created."""
def create_instance_template(*args, **kwargs):
return {'targetLink': 'url'}
self.mock(
instance_templates.gce.Project,
'create_instance_template',
create_instance_template,
)
key = models.InstanceTemplateRevision(
key=instance_templates.get_instance_template_revision_key(
'base-name',
'revision',
),
image_name='image',
metadata={
'key': 'value',
},
project='project',
service_accounts=[
models.ServiceAccount(
name='service-account',
scopes=[
'scope',
],
),
],
).put()
expected_url = 'url'
instance_templates.create(key)
self.assertEqual(key.get().url, expected_url)
def _load_service_accounts(service_accounts):
"""Loads from the given service accounts.
Args:
service_accounts:
proto.config_pb2.InstanceTemplateConfig.InstanceTemplate.ServiceAccount.
Returns:
models.ServiceAccount instance.
"""
return [models.ServiceAccount(name=sa.name, scopes=list(sa.scopes))
for sa in service_accounts]
def test_subscribed(self):
"""Ensures subscribed instance has pending metadata update."""
key = models.Instance(
key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
),
).put()
models.InstanceGroupManager(
key=key.parent(),
).put()
models.InstanceTemplateRevision(
key=key.parent().parent(),
service_accounts=[
models.ServiceAccount(
name='name',
scopes=[
'scope',
],
),
],
).put()
message = {
'ackId': 'id',
'message': {
'attributes': {
'key': key.urlsafe(),
'subscription': 'subscription',
'subscription_project': 'subscription-project',
},
'data': base64.b64encode('SUBSCRIBED'),
},
}
expected_pending_metadata_updates = [
models.MetadataUpdate(
metadata={
'pubsub_service_account': 'name',
'pubsub_subscription': 'subscription',
'pubsub_subscription_project': 'subscription-project',
},
)
]
pubsub.process(message).wait()
self.assertEqual(
key.get().pending_metadata_updates, expected_pending_metadata_updates)
def test_unexpected_key(self):
"""Ensures nothing happens when key has unexpected kind."""
key = models.Instance(
key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
),
).put()
models.InstanceGroupManager(
key=key.parent(),
).put()
models.InstanceTemplateRevision(
key=key.parent().parent(),
service_accounts=[
models.ServiceAccount(
name='name',
scopes=[
'scope',
],
),
],
).put()
message = {
'ackId': 'id',
'message': {
'attributes': {
'key': key.parent().urlsafe(),
'subscription': 'subscription',
'subscription_project': 'subscription-project',
},
'data': base64.b64encode('SUBSCRIBED'),
},
}
pubsub.process(message).wait()
self.failIf(key.get().pending_metadata_updates)
def test_creates_new_entity(self):
"""Ensures that a new entity is created when one doesn't exist."""
template_cfg = config_pb2.InstanceTemplateConfig.InstanceTemplate(
base_name='base-name',
dimensions=[
'os_family:LINUX',
],
disk_size_gb=100,
machine_type='n1-standard-8',
metadata=[
'key:value',
],
service_accounts=[
config_pb2.InstanceTemplateConfig.InstanceTemplate.
ServiceAccount(
name='service-account',
scopes=[
'scope',
],
),
],
tags=[
'tag',
])
manager_cfgs = [
config_pb2.InstanceGroupManagerConfig.InstanceGroupManager(
maximum_size=2,
minimum_size=1,
template_base_name='base-name',
zone='us-central-1a',
),
config_pb2.InstanceGroupManagerConfig.InstanceGroupManager(
maximum_size=3,
minimum_size=2,
template_base_name='base-name',
zone='us-central-1b',
),
config_pb2.InstanceGroupManagerConfig.InstanceGroupManager(
maximum_size=4,
minimum_size=3,
template_base_name='base-name',
zone='us-central-1c',
),
]
expected_instance_template_key = parse.get_instance_template_key(
template_cfg)
expected_instance_template_revision_key = (
parse.get_instance_template_revision_key(template_cfg))
expected_dimensions = parse._load_machine_provider_dimensions(
template_cfg.dimensions)
expected_metadata = parse._load_dict(template_cfg.metadata)
expected_service_accounts = [
models.ServiceAccount(
name=template_cfg.service_accounts[0].name,
scopes=list(template_cfg.service_accounts[0].scopes),
),
]
expected_active_keys = [
parse.get_instance_group_manager_key(template_cfg, manager_cfg)
for manager_cfg in manager_cfgs
]
future = parse.ensure_entities_exist(template_cfg, manager_cfgs)
future.wait()
instance_template_key = future.get_result()
instance_template = instance_template_key.get()
instance_template_revision = instance_template.active.get()
instance_group_managers = sorted(
[
instance_group_manager.get()
for instance_group_manager in instance_template_revision.active
],
key=lambda instance_group_manager: instance_group_manager.key.id(),
)
self.assertEqual(instance_template_key, expected_instance_template_key)
self.assertEqual(instance_template.active,
expected_instance_template_revision_key)
self.assertEqual(instance_template_revision.dimensions,
expected_dimensions)
self.assertEqual(instance_template_revision.disk_size_gb,
template_cfg.disk_size_gb)
self.assertEqual(instance_template_revision.machine_type,
template_cfg.machine_type)
self.assertEqual(instance_template_revision.metadata,
expected_metadata)
self.assertItemsEqual(instance_template_revision.service_accounts,
expected_service_accounts)
self.assertItemsEqual(instance_template_revision.tags,
template_cfg.tags)
self.assertItemsEqual(instance_template_revision.active,
expected_active_keys)
self.assertEqual(instance_group_managers[0].maximum_size,
manager_cfgs[0].maximum_size)
self.assertEqual(instance_group_managers[0].minimum_size,
manager_cfgs[0].minimum_size)
self.assertEqual(instance_group_managers[1].maximum_size,
manager_cfgs[1].maximum_size)
self.assertEqual(instance_group_managers[1].minimum_size,
manager_cfgs[1].minimum_size)
self.assertEqual(instance_group_managers[2].maximum_size,
manager_cfgs[2].maximum_size)
self.assertEqual(instance_group_managers[2].minimum_size,
manager_cfgs[2].minimum_size)
