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_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 compress_metadata_updates(metadata_updates): """Compresses metadata updates into a single update. Args: instance: A list of models.MetadataUpdate instances. Retuns: A models.MetadataUpdate instance. """ metadata = {} for update in metadata_updates: metadata.update(update.metadata) return models.MetadataUpdate(metadata=metadata)
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_parent_not_found(self): """Ensures nothing happens when the parent doesn't exist.""" key = models.Instance( key=instances.get_instance_key( 'base-name', 'revision', 'zone', 'instance-name', ), active_metadata_update=models.MetadataUpdate(metadata={ 'key': 'value', }, ), ).put() metadata.update(key) self.failIf(key.get().active_metadata_update.url)
def test_checksum_mismatch(self): """Ensures nothing happens when the metadata checksum doesn't match.""" key = models.Instance( key=instances.get_instance_key( 'base-name', 'revision', 'zone', 'instance-name', ), active_metadata_update=models.MetadataUpdate(metadata={ 'key': 'value', }, ), ).put() metadata.associate_metadata_operation(key, 'checksum', 'url') self.failIf(key.get().active_metadata_update.url)
def add_subscription_metadata(key, subscription_project, subscription): """Queues the addition of subscription metadata. Args: key: ndb.Key for a models.Instance entity. subscription_project: Project containing the Pub/Sub subscription. subscription: Name of the Pub/Sub subscription that Machine Provider will communicate with the instance on. """ entity = key.get() if not entity: logging.warning('Instance does not exist: %s', key) return if entity.pubsub_subscription: return parent = key.parent().get() if not parent: logging.warning('InstanceGroupManager does not exist: %s', key.parent()) return grandparent = parent.key.parent().get() if not grandparent: logging.warning( 'InstanceTemplateRevision does not exist: %s', parent.key.parent()) return if not grandparent.service_accounts: logging.warning( 'InstanceTemplateRevision service account unspecified: %s', parent.key.parent(), ) return logging.info('Instance Pub/Sub subscription received: %s', key) entity.pending_metadata_updates.append(models.MetadataUpdate( metadata={ 'pubsub_service_account': grandparent.service_accounts[0].name, 'pubsub_subscription': subscription, 'pubsub_subscription_project': subscription_project, }, )) entity.pubsub_subscription = pubsub.full_subscription_name( subscription_project, subscription) entity.put()
def test_project_unspecified(self): """Ensures nothing happens when project is unspecified.""" 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(), ).put() metadata.update(key) self.failIf(key.get().active_metadata_update.url)
def test_associates_url(self): """Ensures a URL is associated.""" key = models.Instance( key=instances.get_instance_key( 'base-name', 'revision', 'zone', 'instance-name', ), active_metadata_update=models.MetadataUpdate(metadata={ 'key': 'value', }, ), ).put() checksum = key.get().active_metadata_update.checksum expected_url = 'url' metadata.associate_metadata_operation(key, checksum, 'url') self.assertEqual(key.get().active_metadata_update.url, expected_url)