def test_not_drained(self):
"""Ensures nothing happens when the parent is not drained."""
def json_request(*args, **kwargs):
self.fail('json_request called')
self.mock(cleanup.net, 'json_request', json_request)
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),
url='url',
).put()
models.InstanceGroupManager(
key=instances.get_instance_group_manager_key(key), ).put()
models.InstanceTemplateRevision(
key=instances.get_instance_group_manager_key(
key).parent(), ).put()
models.InstanceTemplate(key=instances.get_instance_group_manager_key(
key).parent().parent(), ).put()
cleanup.cleanup_drained_instance(key)
self.failIf(key.get().deleted)
def test_deletes_implicitly_drained(self):
"""Ensures an implicitly drained entity is deleted."""
key = models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision',
'zone',
), ).put()
models.InstanceTemplateRevision(
key=key.parent(),
active=[
ndb.Key(models.InstanceGroupManager, 'fake-key-1'),
key,
ndb.Key(models.InstanceGroupManager, 'fake-key-2'),
],
).put()
models.InstanceTemplate(
key=key.parent().parent(),
drained=[
key.parent(),
],
).put()
expected_active = [
ndb.Key(models.InstanceGroupManager, 'fake-key-1'),
ndb.Key(models.InstanceGroupManager, 'fake-key-2'),
]
future = cleanup.delete_instance_group_manager(key)
future.wait()
self.failIf(key.get())
self.assertItemsEqual(key.parent().get().active, expected_active)
def test_active_instances(self):
"""Ensures nothing happens when there are active Instances."""
key = models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision',
'zone',
),
instances=[
ndb.Key(models.Instance, 'fake-key'),
],
).put()
models.InstanceTemplateRevision(
key=key.parent(),
drained=[
key,
],
).put()
models.InstanceTemplate(
key=key.parent().parent(),
active=key.parent(),
).put()
future = cleanup.delete_instance_group_manager(key)
future.wait()
self.failUnless(key.get())
def test_deletes(self):
"""Ensures the entity is deleted."""
key = models.InstanceTemplateRevision(
key=instance_templates.get_instance_template_revision_key(
'base-name',
'revision',
), ).put()
models.InstanceTemplate(
key=key.parent(),
drained=[
ndb.Key(models.InstanceTemplateRevision, 'fake-key-1'),
key,
ndb.Key(models.InstanceTemplateRevision, 'fake-key-2'),
],
).put()
expected_drained = [
ndb.Key(models.InstanceTemplateRevision, 'fake-key-1'),
ndb.Key(models.InstanceTemplateRevision, 'fake-key-2'),
]
future = cleanup.delete_instance_template_revision(key)
future.wait()
self.failIf(key.get())
self.assertItemsEqual(key.parent().get().drained, expected_drained)
def test_implicitly_drained(self):
"""Ensures implicitly drained entities are returned."""
key = models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision',
'zone',
), ).put()
models.InstanceTemplateRevision(
key=key.parent(),
active=[
key,
],
).put()
models.InstanceTemplate(
key=key.parent().parent(),
drained=[
key.parent(),
],
).put()
expected_keys = [
key,
]
self.assertItemsEqual(
instance_group_managers.get_drained_instance_group_managers(),
expected_keys,
)
def test_no_project(self):
def get_instance_group_manager(*args, **kwargs):
self.fail('get_instance_group_manager called')
def resize_managed_instance_group(*args, **kwargs):
self.fail('resize_managed_instance_group called')
self.mock(
instance_group_managers.gce.Project,
'get_instance_group_manager',
get_instance_group_manager,
)
self.mock(
instance_group_managers.gce.Project,
'resize_managed_instance_group',
resize_managed_instance_group,
)
key = models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision',
'zone',
),
minimum_size=10,
maximum_size=10,
url='https://example.com',
).put()
models.InstanceTemplateRevision(key=key.parent(), ).put()
models.InstanceTemplate(key=key.parent().parent()).put()
instance_group_managers.resize(key)
def test_url_specified(self):
"""Ensures nothing happens when the entity still has a URL."""
key = models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision',
'zone',
),
url='url',
).put()
models.InstanceTemplateRevision(
key=key.parent(),
drained=[
key,
],
).put()
models.InstanceTemplate(
key=key.parent().parent(),
active=key.parent(),
).put()
future = cleanup.delete_instance_group_manager(key)
future.wait()
self.failUnless(key.get())
def test_deletes(self):
"""Ensures the entity is deleted."""
key = models.InstanceTemplate().put()
future = cleanup.delete_instance_template(key)
future.wait()
self.failIf(key.get())
def test_nothing_active(self):
"""Ensures nothing happens when nothing is active."""
key = models.InstanceTemplate(
key=instance_templates.get_instance_template_key(
'base-name'), ).put()
parse.ensure_instance_template_revision_drained(key).wait()
self.failIf(key.get().active)
self.failIf(key.get().drained)
def test_active_instance_template_revisions(self):
"""Ensures nothing happens when an instance template revision is active."""
key = models.InstanceTemplate(active=ndb.Key(
models.InstanceTemplateRevision, 'fake-key'), ).put()
future = cleanup.delete_instance_template(key)
future.wait()
self.failUnless(key.get())
def test_multiple_instance_templates_drained_revisions(self):
models.InstanceTemplate(drained=[
ndb.Key(models.InstanceTemplateRevision, 'fake-key-1'),
ndb.Key(models.InstanceTemplateRevision, 'fake-key-2'),
], ).put()
models.InstanceTemplate(
active=ndb.Key(models.InstanceTemplateRevision, 'fake-key-3'),
drained=[
ndb.Key(models.InstanceTemplateRevision, 'fake-key-4'),
],
).put()
expected = [
ndb.Key(models.InstanceTemplateRevision, 'fake-key-1'),
ndb.Key(models.InstanceTemplateRevision, 'fake-key-2'),
ndb.Key(models.InstanceTemplateRevision, 'fake-key-4'),
]
actual = instance_templates.get_drained_instance_template_revisions()
self.assertItemsEqual(actual, expected)
def test_drained_instance_template_revisions(self):
"""Ensures nothing happens when instance template revisions are drained."""
key = models.InstanceTemplate(drained=[
ndb.Key(models.InstanceTemplateRevision, 'fake-key'),
], ).put()
future = cleanup.delete_instance_template(key)
future.wait()
self.failUnless(key.get())
def test_resize_other_revisions_created(self):
def get_instance_group_manager(*args, **kwargs):
return {
'currentActions': {
'none': 0,
},
'name': 'name',
'targetSize': 0,
}
def resize_managed_instance_group(_, name, zone, size):
self.assertEqual(name, 'name')
self.assertEqual(zone, 'zone')
self.assertEqual(size, 4)
self.mock(
instance_group_managers.gce.Project,
'get_instance_group_manager',
get_instance_group_manager,
)
self.mock(
instance_group_managers.gce.Project,
'resize_managed_instance_group',
resize_managed_instance_group,
)
key = models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision-1',
'zone',
),
minimum_size=7,
maximum_size=7,
url='https://example.com',
).put()
models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision-2',
'zone',
),
instances=[
ndb.Key(models.Instance, 'instance-name-1'),
ndb.Key(models.Instance, 'instance-name-2'),
ndb.Key(models.Instance, 'instance-name-3'),
],
).put()
models.InstanceTemplateRevision(
key=key.parent(),
project='fake-project',
).put()
models.InstanceTemplate(key=key.parent().parent()).put()
instance_group_managers.resize(key)
def test_enqueues_task(self):
"""Ensures a task is enqueued."""
key = instance_templates.get_instance_template_revision_key(
'base-name', 'revision')
models.InstanceTemplate(key=key.parent(), active=key).put()
models.InstanceTemplateRevision(key=key).put()
expected_url = key.urlsafe()
instance_templates.schedule_creation()
self.assertEqual(key.get().url, expected_url)
def test_activates(self):
"""Ensures that the instance template revision is activated."""
template_cfg = config_pb2.InstanceTemplateConfig.InstanceTemplate(
base_name='base-name', )
expected_active_key = parse.get_instance_template_revision_key(
template_cfg)
instance_template = models.InstanceTemplate()
self.failUnless(
parse.ensure_instance_template_revision_active(
template_cfg, instance_template))
self.assertEqual(instance_template.active, expected_active_key)
def test_deletes(self):
@ndb.tasklet
def delete_instance_template(key):
yield key.delete_async()
self.mock(
cleanup,
'delete_instance_template',
delete_instance_template,
)
models.InstanceTemplate(key=ndb.Key(models.InstanceTemplate,
'fake-key-1'), ).put()
models.InstanceTemplate(key=ndb.Key(models.InstanceTemplate,
'fake-key-2'), ).put()
models.InstanceTemplate(key=ndb.Key(models.InstanceTemplate,
'fake-key-3'), ).put()
cleanup.cleanup_instance_templates(max_concurrent=2)
self.failIf(ndb.Key(models.InstanceTemplate, 'fake-key-1').get())
self.failIf(ndb.Key(models.InstanceTemplate, 'fake-key-2').get())
self.failIf(ndb.Key(models.InstanceTemplate, 'fake-key-3').get())
def test_instance_template_revision_missing(self):
"""Ensures no task is enqueued for missing instance template revisions."""
key = instance_group_managers.get_instance_group_manager_key(
'base-name', 'revision', 'zone')
models.InstanceTemplate(
key=key.parent().parent(),
active=key.parent(),
).put()
models.InstanceGroupManager(key=key).put()
instance_group_managers.schedule_creation()
self.failIf(key.get().url)
def test_drains_and_activates(self):
"""Ensures that the active instance template revision is drained."""
template_cfg = config_pb2.InstanceTemplateConfig.InstanceTemplate(
base_name='base-name', )
expected_active_key = parse.get_instance_template_revision_key(
template_cfg)
instance_template = models.InstanceTemplate(active=ndb.Key(
models.InstanceTemplateRevision, 'fake-key'), )
self.failUnless(
parse.ensure_instance_template_revision_active(
template_cfg, instance_template))
self.assertEqual(instance_template.active, expected_active_key)
self.assertEqual(instance_template.drained[0].id(), 'fake-key')
def test_enqueues_tasks(self):
"""Ensures tasks are enqueued."""
# Instance template should be created for key1.
key1 = instance_templates.get_instance_template_revision_key(
'base-name-1', 'revision')
models.InstanceTemplate(key=key1.parent(), active=key1).put()
models.InstanceTemplateRevision(key=key1).put()
# key2 refers to an inactive instance template revision. No instance
# template should be created.
key2 = instance_templates.get_instance_template_revision_key(
'base-name-2', 'revision')
models.InstanceTemplate(key=key2.parent()).put()
models.InstanceTemplateRevision(key=key2).put()
# key3 refers to a drained instance template revision. No instance
# template should be created.
key3 = instance_templates.get_instance_template_revision_key(
'base-name-3', 'revision')
models.InstanceTemplate(key=key3.parent(), drained=[key3]).put()
models.InstanceTemplateRevision(key=key3).put()
# key4 refers to an active instance template revision that does not
# exist. No instance template should be created.
key4 = instance_templates.get_instance_template_revision_key(
'base-name-4', 'revision')
models.InstanceTemplate(key=key4.parent(), active=key4).put()
# Instance template should be created for key5.
key5 = instance_templates.get_instance_template_revision_key(
'base-name-5', 'revision')
models.InstanceTemplate(key=key5.parent(), active=key5).put()
models.InstanceTemplateRevision(key=key5).put()
instance_templates.schedule_creation()
self.assertEqual(key1.get().url, key1.urlsafe())
self.failIf(key2.get().url)
self.failIf(key3.get().url)
self.failIf(key4.get())
self.assertEqual(key5.get().url, key5.urlsafe())
def test_active(self):
"""Ensures nothing happens when the entity is active."""
key = models.InstanceTemplateRevision(
key=instance_templates.get_instance_template_revision_key(
'base-name',
'revision',
), ).put()
models.InstanceTemplate(
key=key.parent(),
active=key,
).put()
future = cleanup.delete_instance_template_revision(key)
future.wait()
self.failUnless(key.get())
def test_parent_doesnt_exist(self):
"""Ensures nothing happens when the parent doesn't exist."""
key = models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision',
'zone',
), ).put()
models.InstanceTemplate(
key=key.parent().parent(),
active=key.parent(),
).put()
future = cleanup.delete_instance_group_manager(key)
future.wait()
self.failUnless(key.get())
def test_drains(self):
"""Ensures active InstanceTemplateRevision is drained."""
key = instance_templates.get_instance_template_revision_key(
'base-name',
'revision',
)
models.InstanceTemplate(
key=key.parent(),
active=key,
).put()
expected_drained = [
key,
]
parse.ensure_instance_template_revision_drained(key.parent()).wait()
self.failIf(key.parent().get().active)
self.assertEqual(key.parent().get().drained, expected_drained)
def test_instance_group_manager_inactive(self):
"""Ensures no task is enqueued for inactive instance group managers."""
key = instance_group_managers.get_instance_group_manager_key(
'base-name', 'revision', 'zone')
models.InstanceTemplate(
key=key.parent().parent(),
active=key.parent(),
).put()
models.InstanceTemplateRevision(
key=key.parent(),
url='url',
).put()
models.InstanceGroupManager(key=key).put()
instance_group_managers.schedule_creation()
self.failIf(key.get().url)
def test_get_base_name(self):
"""Ensures base instance name is generated correctly."""
key = models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision-extra-long',
'zone',
),
minimum_size=10,
maximum_size=10,
url='https://example.com',
).put()
models.InstanceTemplateRevision(key=key.parent(), ).put()
models.InstanceTemplate(key=key.parent().parent()).put()
self.assertEqual(
instance_group_managers.get_base_name(key.get()),
'base-name-revision-zone',
)
def test_already_active(self):
"""Ensures that the active instance template revision remains active."""
template_cfg = config_pb2.InstanceTemplateConfig.InstanceTemplate(
base_name='base-name', )
expected_active_key = parse.get_instance_template_revision_key(
template_cfg)
instance_template = models.InstanceTemplate(
active=parse.get_instance_template_revision_key(template_cfg),
drained=[
ndb.Key(models.InstanceTemplateRevision, 'fake-key'),
],
)
self.failIf(
parse.ensure_instance_template_revision_active(
template_cfg, instance_template))
self.assertEqual(instance_template.active, expected_active_key)
self.assertEqual(len(instance_template.drained), 1)
self.assertEqual(instance_template.drained[0].id(), 'fake-key')
def test_reactivates(self):
"""Ensures that the drained instance template revision is reactivated."""
template_cfg = config_pb2.InstanceTemplateConfig.InstanceTemplate(
base_name='base-name', )
expected_active_key = parse.get_instance_template_revision_key(
template_cfg)
instance_template = models.InstanceTemplate(drained=[
ndb.Key(models.InstanceTemplateRevision, 'fake-key-1'),
parse.get_instance_template_revision_key(template_cfg),
ndb.Key(models.InstanceTemplateRevision, 'fake-key-2'),
], )
self.failUnless(
parse.ensure_instance_template_revision_active(
template_cfg, instance_template))
self.assertEqual(instance_template.active, expected_active_key)
self.assertEqual(len(instance_template.drained), 2)
self.assertEqual(instance_template.drained[0].id(), 'fake-key-1')
self.assertEqual(instance_template.drained[1].id(), 'fake-key-2')
def test_resize_some_created(self):
def get_instance_group_manager(*args, **kwargs):
return {
'currentActions': {
'none': 3,
},
'name': 'name',
}
def resize_managed_instance_group(_, name, zone, size):
self.assertEqual(name, 'name')
self.assertEqual(zone, 'zone')
self.assertEqual(size, 103)
self.mock(
instance_group_managers.gce.Project,
'get_instance_group_manager',
get_instance_group_manager,
)
self.mock(
instance_group_managers.gce.Project,
'resize_managed_instance_group',
resize_managed_instance_group,
)
key = models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision',
'zone',
),
minimum_size=1000,
url='https://example.com',
).put()
models.InstanceTemplateRevision(
key=key.parent(),
project='fake-project',
).put()
models.InstanceTemplate(key=key.parent().parent()).put()
instance_group_managers.resize(key)
def test_resize_excess_created(self):
def get_instance_group_manager(*args, **kwargs):
return {
'currentActions': {
'none': 2,
},
'name': 'name',
'targetSize': 2,
}
def resize_managed_instance_group(_, name, zone, size):
self.failIf(True)
self.mock(
instance_group_managers.gce.Project,
'get_instance_group_manager',
get_instance_group_manager,
)
self.mock(
instance_group_managers.gce.Project,
'resize_managed_instance_group',
resize_managed_instance_group,
)
key = models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision',
'zone',
),
minimum_size=1,
maximum_size=1,
url='https://example.com',
).put()
models.InstanceTemplateRevision(
key=key.parent(),
project='fake-project',
).put()
models.InstanceTemplate(key=key.parent().parent()).put()
instance_group_managers.resize(key)
def test_enqueues_task(self):
"""Ensures a task is enqueued."""
key = instance_group_managers.get_instance_group_manager_key(
'base-name', 'revision', 'zone')
models.InstanceTemplate(
key=key.parent().parent(),
active=key.parent(),
).put()
models.InstanceTemplateRevision(
key=key.parent(),
active=[
key,
],
url='url',
).put()
models.InstanceGroupManager(key=key).put()
expected_url = key.urlsafe()
instance_group_managers.schedule_creation()
self.assertEqual(key.get().url, expected_url)
def test_instance_group_manager_already_created(self):
"""Ensures no task is enqueued for existing instance group managers."""
key = instance_group_managers.get_instance_group_manager_key(
'base-name', 'revision', 'zone')
models.InstanceTemplate(
key=key.parent().parent(),
active=key.parent(),
).put()
models.InstanceTemplateRevision(
key=key.parent(),
active=[
key,
],
url='instance-template-url',
).put()
models.InstanceGroupManager(key=key, url='url').put()
expected_url = 'url'
instance_group_managers.schedule_creation()
self.assertEqual(key.get().url, expected_url)
