def test_deleted_not_done(self):
"""Ensures nothing happens when instance deletion status is not DONE."""
def json_request(*args, **kwargs):
return {'status': 'error'}
def send_machine_event(*args, **kwargs):
pass
self.mock(instances.net, 'json_request', json_request)
self.mock(instances.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),
pending_deletion=True,
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(),
project='project',
).put()
instances.delete_pending(key)
def test_already_exists(self):
"""Ensures nothing happens when the entity already exists."""
def fetch(*args, **kwargs):
return ['url/name']
self.mock(instances, 'fetch', fetch)
key = models.Instance(
key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'name',
),
).put()
models.InstanceGroupManager(
key=key.parent(),
url='url',
).put()
expected_instances = [
key,
]
instances.ensure_entities_exist(key.parent())
self.failIf(key.get().url)
self.assertItemsEqual(key.parent().get().instances, expected_instances)
def test_dimensions(self):
"""Ensures dimensions are returned."""
instance = models.Instance(key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
), )
instance_template_revision = models.InstanceTemplateRevision(
dimensions=machine_provider.Dimensions(
os_family=machine_provider.OSFamily.LINUX, ),
disk_size_gb=300,
machine_type='n1-standard-8',
)
expected_dimensions = {
'backend': 'GCE',
'disk_size_gb': 300,
'hostname': 'instance-name',
'memory_gb': 30,
'num_cpus': 8,
'os_family': 'LINUX',
}
self.assertEqual(
catalog.extract_dimensions(instance, instance_template_revision),
expected_dimensions,
)
def update_or_create_instance(volume, f):
#instance with oshash exists
instance = models.Instance.objects.filter(file__oshash=f['oshash'],
volume=volume)
if instance.count() > 0:
instance = instance[0]
updated = False
for key in _INSTANCE_KEYS:
if f[key] != getattr(instance, key):
setattr(instance, key, f[key])
updated = True
if updated:
instance.ignore = False
instance.save()
instance.file.save()
else:
instance = models.Instance.objects.filter(path=f['path'],
volume=volume)
if instance.count() > 0:
#same path, other oshash, keep path/item mapping, remove instance
item = instance[0].file.item
instance.delete()
else: #new instance
item = None
instance = models.Instance()
instance.volume = volume
instance.file = get_or_create_file(volume, f, volume.user, item)
for key in _INSTANCE_KEYS:
setattr(instance, key, f[key])
instance.save()
instance.file.save()
if instance.file.item:
instance.file.item.update_wanted()
return instance
def test_grandparent_unspecified(self):
"""Ensures nothing happens when the grandparent doesn't exist."""
def json_request(*args, **kwargs):
self.fail('json_request called')
def send_machine_event(*args, **kwargs):
self.fail('send_machine_event called')
self.mock(instances.net, 'json_request', json_request)
self.mock(instances.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),
pending_deletion=True,
url='url',
).put()
models.InstanceGroupManager(
key=instances.get_instance_group_manager_key(key), ).put()
instances.delete_pending(key)
def test_metadata_updated(self):
"""Ensures metadata is updated."""
def json_request(*args, **kwargs):
return {'metadata': {'fingerprint': 'fingerprint', 'items': []}}
def set_metadata(*args, **kwargs):
return collections.namedtuple('operation', ['url'])(url='url')
self.mock(metadata.net, 'json_request', json_request)
self.mock(metadata.gce.Project, 'set_metadata', set_metadata)
key = models.Instance(
key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
),
active_metadata_update=models.MetadataUpdate(metadata={
'key': 'value',
}, ),
).put()
models.InstanceGroupManager(key=key.parent(), ).put()
models.InstanceTemplateRevision(
key=key.parent().parent(),
project='project',
).put()
expected_url = 'url'
metadata.update(key)
self.assertEqual(key.get().active_metadata_update.url, expected_url)
def test_not_cataloged(self):
"""Ensures an instance is set for deletion when not cataloged."""
def delete_machine(*args, **kwargs):
return {'error': 'ENTRY_NOT_FOUND'}
def send_machine_event(*args, **kwargs):
pass
self.mock(catalog.machine_provider, 'delete_machine', delete_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,
cataloged=False,
instance_group_manager=instances.get_instance_group_manager_key(
key),
).put()
catalog.remove(key)
self.failIf(key.get().cataloged)
self.failUnless(key.get().pending_deletion)
class ManualRegisterForm(FlaskForm):
Userperson_username = TextField() #CharField(unique #True)
Userperson_password = PasswordField() #CharField(null #False)
Userperson_person = HiddenField(default='ForeignKey_Person') #ForeignKeyField(Person, related_name #'person_userpersons', null #True)
#Userperson_instance = HiddenField(default='SelectForeignKey_Instance') #ForeignKeyField(Instance, related_name #'instance_userspersons', null #True)
Userperson_instance = SelectField(choices=[(x.id, x) for x in models.Instance().select()])
Person_firstname = TextField() #CharField()
Person_lastname = TextField() #CharField()
Person_title = TextField() #CharField()
Person_address = HiddenField(default='ForeignKey_Address') #ForeignKeyField(Address, related_name #'address_persons', null #True)
Person_telephone = TextField() #CharField()
Person_email = TextField() #CharField()
Person_position = TextField() #CharField()
Person_category = TextField() #CharField()
Person_company = HiddenField(default='ForeignKey_Company') #ForeignKeyField()
Company_companyname = TextField() #CharField()
Company_address = HiddenField(default='ForeignKey_Address') #ForeignKeyField(Address, related_name #'address_companies')
#Instance_name = TextField() #CharField()
#Instance_address = HiddenField(default='ForeignKey_Address') #ForeignKeyField(Address, related_name #'address_Instances', null #True)
#Instance_active = BooleanField() #BooleanField()
#Instance_category = TextField() #CharField()
Address_postaddress = TextField() #CharField()
Address_postalcode = IntegerField() #IntegerField()
Address_country = TextField() #CharField()
Address_telephone = TextField() #CharField()
submit = SubmitField('Save')
def test_deletion_ts(self):
"""Ensures deletion_ts is not overwritten, but deletion call is repeated."""
def json_request(*args, **kwargs):
return {'status': 'DONE'}
def send_machine_event(*args, **kwargs):
pass
self.mock(instances.net, 'json_request', json_request)
self.mock(instances.metrics, 'send_machine_event', send_machine_event)
now = utils.utcnow()
key = instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
)
key = models.Instance(
key=key,
deletion_ts=now,
instance_group_manager=instances.get_instance_group_manager_key(
key),
pending_deletion=True,
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(),
project='project',
).put()
instances.delete_pending(key)
self.assertEqual(key.get().deletion_ts, now)
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_service_account_not_found(self):
"""Ensures nothing happens when a service account doesn't exist."""
def add_machine(*args, **kwargs):
self.fail('add_machine called')
self.mock(catalog.machine_provider, 'add_machine', add_machine)
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(), ).put()
catalog.catalog(key)
self.failIf(key.get().cataloged)
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_updated_lease_expiration_ts(self):
"""Ensures an instance can be updated with a lease_expiration_ts."""
now = int(utils.time_time())
def retrieve_machine(*args, **kwargs):
return {
'lease_expiration_ts': str(now),
}
self.mock(catalog.machine_provider, 'retrieve_machine',
retrieve_machine)
key = instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
)
key = models.Instance(
key=key,
cataloged=True,
instance_group_manager=instances.get_instance_group_manager_key(
key),
).put()
self.failIf(key.get().leased)
catalog.update_cataloged_instance(key)
self.failUnless(key.get().cataloged)
self.assertEqual(key.get().lease_expiration_ts,
datetime.datetime.utcfromtimestamp(now))
self.failUnless(key.get().leased)
self.failIf(key.get().pending_deletion)
def test_not_cataloged(self):
"""Ensures nothing happens when the instance is not cataloged."""
def retrieve_machine(*args, **kwargs):
self.fail('retrieve_machine called')
self.mock(catalog.machine_provider, 'retrieve_machine',
retrieve_machine)
key = instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
)
key = models.Instance(
key=key,
cataloged=False,
instance_group_manager=instances.get_instance_group_manager_key(
key),
).put()
catalog.update_cataloged_instance(key)
self.failIf(key.get().cataloged)
self.failIf(key.get().leased)
self.failIf(key.get().pending_deletion)
def test_not_pending_deletion(self):
"""Ensures nothing happens when the instance isn't pending deletion."""
def json_request(*args, **kwargs):
self.fail('json_request called')
def send_machine_event(*args, **kwargs):
self.fail('send_machine_event called')
self.mock(instances.net, 'json_request', json_request)
self.mock(instances.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),
pending_deletion=False,
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(),
project='project',
).put()
instances.delete_pending(key)
def test_deleted(self):
"""Ensures the entity is marked deleted when the instance doesn't exists."""
def json_request(*args, **kwargs):
raise net.NotFoundError('404', 404, '404')
def send_machine_event(*args, **kwargs):
pass
self.mock(cleanup.net, 'json_request', json_request)
self.mock(cleanup.metrics, 'send_machine_event', send_machine_event)
key = models.Instance(
key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
),
pending_deletion=True,
url='url',
).put()
cleanup.check_deleted_instance(key)
self.failUnless(key.get().deleted)
def test_retrieval_error(self):
"""Ensures an instance is set for deletion when not found."""
def retrieve_machine(*args, **kwargs):
raise net.NotFoundError('404', 404, '404')
def send_machine_event(*args, **kwargs):
pass
self.mock(catalog.machine_provider, 'retrieve_machine',
retrieve_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,
cataloged=True,
instance_group_manager=instances.get_instance_group_manager_key(
key),
).put()
catalog.update_cataloged_instance(key)
self.failUnless(key.get().cataloged)
self.failIf(key.get().leased)
self.failUnless(key.get().pending_deletion)
def test_error_surfaced(self):
"""Ensures errors are surfaced."""
def json_request(*args, **kwargs):
raise net.Error('403', 403, '403')
def send_machine_event(*args, **kwargs):
pass
self.mock(instances.net, 'json_request', json_request)
self.mock(instances.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),
pending_deletion=True,
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(),
project='project',
).put()
self.assertRaises(net.Error, instances.delete_pending, key)
def test_removed(self):
"""Ensures an instance can be removed."""
def delete_machine(*args, **kwargs):
return {}
def send_machine_event(*args, **kwargs):
pass
self.mock(catalog.machine_provider, 'delete_machine', delete_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,
cataloged=True,
instance_group_manager=instances.get_instance_group_manager_key(
key),
).put()
catalog.remove(key)
self.failUnless(key.get().cataloged)
self.failUnless(key.get().pending_deletion)
def test_pending_metadata_updates(self):
"""Ensures pending metadata updates are compressed and activated."""
key = models.Instance(
key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
),
pending_metadata_updates=[
models.MetadataUpdate(metadata={'key1': 'value1'}),
models.MetadataUpdate(metadata={'key2': 'value2'}),
models.MetadataUpdate(metadata={
'key3': 'value3',
'key1': 'value'
}),
],
).put()
expected_active_metadata_update = models.MetadataUpdate(
metadata={
'key1': 'value',
'key2': 'value2',
'key3': 'value3',
})
metadata.compress_pending_metadata_updates(key)
self.assertEqual(key.get().active_metadata_update,
expected_active_metadata_update)
self.failIf(key.get().pending_metadata_updates)
def test_active_metadata_update(self):
"""Ensures nothing happens when a metadata update is already active."""
key = models.Instance(
key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
),
active_metadata_update=models.MetadataUpdate(
metadata={'key1': 'value1'}, ),
pending_metadata_updates=[
models.MetadataUpdate(metadata={'key2': 'value2'}),
],
).put()
expected_active_metadata_update = models.MetadataUpdate(
metadata={'key1': 'value1'}, )
expected_pending_metadata_updates = [
models.MetadataUpdate(metadata={'key2': 'value2'}),
]
metadata.compress_pending_metadata_updates(key)
self.assertEqual(key.get().active_metadata_update,
expected_active_metadata_update)
self.assertEqual(key.get().pending_metadata_updates,
expected_pending_metadata_updates)
def test_no_active_metadata_update(self):
"""Ensures nothing happens when active metadata update is unspecified."""
key = models.Instance(key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
), ).put()
metadata.associate_metadata_operation(key, 'checksum', 'url')
self.failIf(key.get().active_metadata_update)
def ensure_entity_exists(key, url):
"""Ensures an Instance entity exists.
Args:
key: ndb.Key for a models.Instance entity.
url: URL for the instance.
"""
entity = yield key.get_async()
if entity:
return
yield models.Instance(key=key, url=url).put_async()
def test_no_pending_metadata_updates(self):
"""Ensures nothing happens when there are no pending metadata updates."""
key = models.Instance(key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
), ).put()
metadata.compress_pending_metadata_updates(key)
self.failIf(key.get().active_metadata_update)
self.failIf(key.get().pending_metadata_updates)
def test_sets(self):
"""Ensures the deletion_ts can be set."""
now = utils.utcnow()
key = models.Instance(key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
), ).put()
instances.set_deletion_time(key, now)
self.assertEqual(key.get().deletion_ts, now)
def test_lease_expiration_ts_added(self):
now = utils.utcnow()
key = models.Instance(key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
), ).put()
instances.add_lease_expiration_ts(key, now)
self.assertEqual(key.get().lease_expiration_ts, now)
self.failUnless(key.get().leased)
def test_entity_exists(self):
"""Ensures nothing happens when the entity already exists."""
key = models.Instance(key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
), ).put()
future = instances.ensure_entity_exists(key, 'url')
future.wait()
self.failIf(key.get().url)
def ensure_entity_exists(key, url):
"""Ensures an Instance entity exists.
Args:
key: ndb.Key for a models.Instance entity.
url: URL for the instance.
"""
entity = yield key.get_async()
if entity:
logging.info('Instance entity already exists: %s', key)
return
logging.info('Creating Instance entity: %s', key)
yield models.Instance(key=key, url=url).put_async()
metrics.send_machine_event('CREATED', key.id())
def test_drained(self):
"""Ensures the entity is marked as deleted when drained."""
key = models.Instance(
key=instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
),
pending_deletion=False,
).put()
cleanup.set_instance_deleted(key, True)
self.failUnless(key.get().deleted)
def test_cataloged(self):
"""Ensures an instance can be cataloged."""
key = instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
)
key = models.Instance(
key=key,
cataloged=False,
).put()
catalog.set_cataloged(key)
self.failUnless(key.get().cataloged)
