def test_serialize_deserialize():
value = DeploymentDefinitions(
nodes={
'111':
DeploymentDefinition(value={
'a': 1,
'b': '2'
},
expiration_date=(datetime.datetime(
2018, 11, 12, 13, 14).replace(
tzinfo=dateutil.tz.tzutc()))),
'222':
DeploymentDefinition(value={
'c': 3,
'd': '4'
},
expiration_date=(datetime.datetime(
2018, 11, 16, 17, 18).replace(
tzinfo=dateutil.tz.tzutc())))
})
serialized = value.serialize()
assert serialized == {
'type': 'SerializableTypes.DEPLOYMENT_DEFINITIONS',
'nodes': {
'111': {
'type': 'SerializableTypes.DEPLOYMENT_DEFINITION',
'value': {
'a': 1,
'b': '2'
},
'expiration_date': '2018-11-12T13:14:00+00:00'
},
'222': {
'type': 'SerializableTypes.DEPLOYMENT_DEFINITION',
'value': {
'c': 3,
'd': '4'
},
'expiration_date': '2018-11-16T17:18:00+00:00'
}
},
'jupyter_deployments': {},
'dask_deployments': {}
}
deserialized = DeploymentDefinitions.deserialize(serialized=serialized)
assert deserialized == value
def test_definitions_can_be_added():
deployments = DeploymentDefinitions()
deployment1 = get_deployment_for_test(uuid='111', job_id=1)
assert not deployments.nodes
add_deployment_definition(deployments=deployments,
deployment=deployment1)
assert len(deployments.nodes) == 1
deployment2 = get_deployment_for_test(uuid='222', job_id=2)
add_deployment_definition(deployments=deployments,
deployment=deployment2)
assert len(deployments.nodes) == 2
assert deployments.nodes['111'].value == deployment1.serialize()
assert deployments.nodes['222'].value == deployment2.serialize()
def discard_expired_deployments(
deployments: DeploymentDefinitions) -> DeploymentDefinitions: # noqa
"""Returns a new object that does not contain deployments
that have expired, or will expire in the near future.
:param deployments: Deployments to examine.
"""
log = get_logger(__name__)
with stage_debug(log, "Discarding expired deployments."):
now = utc_now()
log.debug("Now: %s", now)
log.debug(
"Will discard after the %d second mark"
" before the expiration date.", DISCARD_DELTA_SECONDS)
discard_now = utc_now() + timedelta(seconds=DISCARD_DELTA_SECONDS)
unexpired_nodes = {}
for uuid, node in deployments.nodes.items():
if node.expiration_date < discard_now:
log.warning(
"Discarding a synchronized allocation deployment,"
" because it has expired: %s", uuid)
else:
unexpired_nodes[uuid] = node
unexpired_jupyter_deployments = {}
for uuid, jupyter in deployments.jupyter_deployments.items():
if jupyter.expiration_date < discard_now:
log.warning(
"Discarding a Jupyter deployment,"
" because it has expired: %s", uuid)
else:
unexpired_jupyter_deployments[uuid] = jupyter
unexpired_dask_deployments = {}
for uuid, dask in deployments.dask_deployments.items():
if dask.expiration_date < discard_now:
log.warning(
"Discarding a Dask deployment,"
" because it has expired: %s", uuid)
else:
unexpired_dask_deployments[uuid] = dask
return DeploymentDefinitions(
nodes=unexpired_nodes,
jupyter_deployments=unexpired_jupyter_deployments,
dask_deployments=unexpired_dask_deployments)
def deserialize_deployment_definitions_from_cluster(
node: NodeInternal) -> DeploymentDefinitions: # noqa
"""Downloads deployment definitions from the cluster.
:param node: Node to deserialize deployment definitions from.
"""
log = get_logger(__name__)
with stage_debug(log, "Deserializing deployment definitions"
" from cluster."):
path = get_deployment_definitions_file_path(node=node)
file_contents = get_file_from_node(node=node, remote_path=path)
serialized = json.loads(file_contents)
return DeploymentDefinitions.deserialize(serialized=serialized)
def test_definition_with_the_same_uuid_is_replaced():
deployments = DeploymentDefinitions()
deployment_old = get_deployment_for_test(uuid='111', job_id=1)
assert not deployments.nodes
add_deployment_definition(deployments=deployments,
deployment=deployment_old)
assert len(deployments.nodes) == 1
assert deployments.nodes['111'].value == deployment_old.serialize()
deployment_new = get_deployment_for_test(uuid='111', job_id=2)
assert deployment_new.serialize() != deployment_old.serialize()
add_deployment_definition(deployments=deployments,
deployment=deployment_new)
assert len(deployments.nodes) == 1
assert deployments.nodes['111'].value == deployment_new.serialize()
def serialize_deployment_definitions_to_cluster(
node: NodeInternal, deployments: DeploymentDefinitions): # noqa
"""Uploads deployment definitions to the cluster, replacing
any definitions file already there.
:param node: Node to serialize definitions to.
:param deployments: Deployments to upload.
"""
log = get_logger(__name__)
with stage_debug(log, "Serializing deployment definitions to cluster."):
serialized = deployments.serialize()
file_contents = json.dumps(serialized, sort_keys=True, indent=4)
parent_path = get_deployment_definitions_parent_path(node=node)
node.run("mkdir -p {parent_path}"
" && chmod 700 {parent_path}".format(parent_path=parent_path))
path = get_deployment_definitions_file_path(node=node)
put_file_on_node(node=node, remote_path=path, contents=file_contents)
def push_deployment(self, deployment: Union[Nodes,
JupyterDeployment,
DaskDeployment]):
log = get_logger(__name__)
with stage_info(log, "Pushing deployment: %s", deployment):
log = get_logger(__name__)
node = self.get_access_node()
if deployment_definitions_file_exists(node=node):
deployments = deserialize_deployment_definitions_from_cluster(
node=node)
else:
log.debug(
"No deployment definitions file, defaulting to empty.")
deployments = DeploymentDefinitions()
deployments = discard_expired_deployments(deployments)
add_deployment_definition(deployments=deployments,
deployment=deployment)
serialize_deployment_definitions_to_cluster(
node=node,
deployments=deployments)
def test_missing_serialized_keys():
serialized = {'type': 'SerializableTypes.DEPLOYMENT_DEFINITIONS'}
deserialized = DeploymentDefinitions.deserialize(serialized=serialized)
assert deserialized == DeploymentDefinitions()
def test_invalid_serialized_type():
serialized = {'type': 'SerializableTypes.DEPLOYMENT_DEFINITIONS2'}
with pytest.raises(AssertionError):
DeploymentDefinitions.deserialize(serialized=serialized)
def test_discard_expired_deployments():
base = datetime.datetime(2017, 11, 12, 10, 00).replace(
tzinfo=dateutil.tz.tzutc())
deployments = DeploymentDefinitions(
nodes={
'30s in the past': DeploymentDefinition(
value={},
expiration_date=base - datetime.timedelta(seconds=30)),
'15s in the past': DeploymentDefinition(
value={},
expiration_date=base - datetime.timedelta(seconds=15)),
'now': DeploymentDefinition(
value={},
expiration_date=base),
'15s in the future': DeploymentDefinition(
value={},
expiration_date=base + datetime.timedelta(seconds=15)),
'30s in the future': DeploymentDefinition(
value={},
expiration_date=base + datetime.timedelta(seconds=30)),
'45s in the future': DeploymentDefinition(
value={},
expiration_date=base + datetime.timedelta(seconds=45)),
'60s in the future': DeploymentDefinition(
value={},
expiration_date=base + datetime.timedelta(seconds=60))},
jupyter_deployments={
'-30s Jupyter': DeploymentDefinition(
value={},
expiration_date=base - datetime.timedelta(seconds=30)),
'+60s Jupyter': DeploymentDefinition(
value={},
expiration_date=base + datetime.timedelta(seconds=60))})
assert len(deployments.nodes) == 7
assert len(deployments.jupyter_deployments) == 2
old_utc_now = \
idact.detail.deployment_sync.discard_expired_deployments.utc_now
def fake_utc_now():
return base
try:
idact.detail.deployment_sync.discard_expired_deployments.utc_now = \
fake_utc_now
new_deployments = discard_expired_deployments(deployments=deployments)
finally:
idact.detail.deployment_sync.discard_expired_deployments.utc_now = \
old_utc_now
assert len(deployments.nodes) == 7
assert len(deployments.jupyter_deployments) == 2
assert new_deployments.nodes == {
'30s in the future': DeploymentDefinition(
value={},
expiration_date=base + datetime.timedelta(seconds=30)),
'45s in the future': DeploymentDefinition(
value={},
expiration_date=base + datetime.timedelta(seconds=45)),
'60s in the future': DeploymentDefinition(
value={},
expiration_date=base + datetime.timedelta(seconds=60))}
assert new_deployments.jupyter_deployments == {
'+60s Jupyter': DeploymentDefinition(
value={},
expiration_date=base + datetime.timedelta(seconds=60))}