X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=juju%2Fmachine.py;h=18c333c17c11e3e29ccd9348aa62f7257719247d;hb=d6348ef405d6e87a4f72e7842ea4376678456283;hp=44560bfd8305838907da15a2261bd78d95bb6ea8;hpb=afb309d17dadc062017ee3d6425491193181138e;p=osm%2FN2VC.git diff --git a/juju/machine.py b/juju/machine.py index 44560bf..18c333c 100644 --- a/juju/machine.py +++ b/juju/machine.py @@ -1,20 +1,93 @@ import logging -from . import model +from dateutil.parser import parse as parse_date + +from . import model, utils from .client import client log = logging.getLogger(__name__) class Machine(model.ModelEntity): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.on_change(self._workaround_1695335) + + async def _workaround_1695335(self, delta, old, new, model): + """ + This is a (hacky) temporary work around for a bug in Juju where the + instance status and agent version fields don't get updated properly + by the AllWatcher. + + Deltas never contain a value for `data['agent-status']['version']`, + and once the `instance-status` reaches `pending`, we no longer get + any updates for it (the deltas come in, but the `instance-status` + data is always the same after that). + + To work around this, whenever a delta comes in for this machine, we + query FullStatus and use the data from there if and only if it's newer. + Luckily, the timestamps on the `since` field does seem to be accurate. + + See https://bugs.launchpad.net/juju/+bug/1695335 + """ + if delta.data.get('synthetic', False): + # prevent infinite loops re-processing already processed deltas + return + + full_status = await utils.run_with_interrupt(model.get_status(), + model._watch_stopping, + model.loop) + if model._watch_stopping.is_set(): + return + + if self.id not in full_status.machines: + return + + if not full_status.machines[self.id]['instance-status']['since']: + return + + machine = full_status.machines[self.id] + + change_log = [] + key_map = { + 'status': 'current', + 'info': 'message', + 'since': 'since', + } + + # handle agent version specially, because it's never set in + # deltas, and we don't want even a newer delta to clear it + agent_version = machine['agent-status']['version'] + if agent_version: + delta.data['agent-status']['version'] = agent_version + change_log.append(('agent-version', '', agent_version)) + + # only update (other) delta fields if status data is newer + status_since = parse_date(machine['instance-status']['since']) + delta_since = parse_date(delta.data['instance-status']['since']) + if status_since > delta_since: + for status_key in ('status', 'info', 'since'): + delta_key = key_map[status_key] + status_value = machine['instance-status'][status_key] + delta_value = delta.data['instance-status'][delta_key] + change_log.append((delta_key, delta_value, status_value)) + delta.data['instance-status'][delta_key] = status_value + + if change_log: + log.debug('Overriding machine delta with FullStatus data') + for log_item in change_log: + log.debug(' {}: {} -> {}'.format(*log_item)) + delta.data['synthetic'] = True + old_obj, new_obj = self.model.state.apply_delta(delta) + await model._notify_observers(delta, old_obj, new_obj) + async def destroy(self, force=False): """Remove this machine from the model. Blocks until the machine is actually removed. """ - facade = client.ClientFacade() - facade.connect(self.connection) + facade = client.ClientFacade.from_connection(self.connection) log.debug( 'Destroying machine %s', self.id) @@ -31,7 +104,7 @@ class Machine(model.ModelEntity): :param int timeout: Time to wait before command is considered failed """ - pass + raise NotImplementedError() async def set_annotations(self, annotations): """Set annotations on this machine. @@ -42,8 +115,8 @@ class Machine(model.ModelEntity): """ log.debug('Updating annotations on machine %s', self.id) - self.ann_facade = client.AnnotationsFacade() - self.ann_facade.connect(self.connection) + self.ann_facade = client.AnnotationsFacade.from_connection( + self.connection) ann = client.EntityAnnotations( entity=self.id, @@ -64,7 +137,7 @@ class Machine(model.ModelEntity): :param str scp_opts: Additional options to the `scp` command """ - pass + raise NotImplementedError() def ssh( self, command, user=None, proxy=False, ssh_opts=None): @@ -76,7 +149,7 @@ class Machine(model.ModelEntity): :param str ssh_opts: Additional options to the `ssh` command """ - pass + raise NotImplementedError() def status_history(self, num=20, utc=False): """Get status history for this machine. @@ -85,4 +158,51 @@ class Machine(model.ModelEntity): :param bool utc: Display time as UTC in RFC3339 format """ - pass + raise NotImplementedError() + + @property + def agent_status(self): + """Returns the current Juju agent status string. + + """ + return self.safe_data['agent-status']['current'] + + @property + def agent_status_since(self): + """Get the time when the `agent_status` was last updated. + + """ + return parse_date(self.safe_data['agent-status']['since']) + + @property + def agent_version(self): + """Get the version of the Juju machine agent. + + May return None if the agent is not yet available. + """ + version = self.safe_data['agent-status']['version'] + if version: + return client.Number.from_json(version) + else: + return None + + @property + def status(self): + """Returns the current machine provisioning status string. + + """ + return self.safe_data['instance-status']['current'] + + @property + def status_message(self): + """Returns the current machine provisioning status message. + + """ + return self.safe_data['instance-status']['message'] + + @property + def status_since(self): + """Get the time when the `status` was last updated. + + """ + return parse_date(self.safe_data['instance-status']['since'])