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)
