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)