X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=juju%2Funit.py;h=ab9d1d02b9cce4fc201212cf3e16bfd7c007f7dc;hb=41ba4699c6b3f636fb75eb27322e2dfa81f3313e;hp=d0bbd32a1122240b1511827aaad89ed5f4e67d67;hpb=bccd5c73a2f02a768612c7aec318c910fceda299;p=osm%2FN2VC.git diff --git a/juju/unit.py b/juju/unit.py index d0bbd32..ab9d1d0 100644 --- a/juju/unit.py +++ b/juju/unit.py @@ -1,5 +1,6 @@ import logging -from datetime import datetime + +from dateutil.parser import parse as parse_date from . import model from .client import client @@ -13,48 +14,46 @@ class Unit(model.ModelEntity): """Returns the current agent status string. """ - return self.data['agent-status']['current'] + return self.safe_data['agent-status']['current'] @property def agent_status_since(self): """Get the time when the `agent_status` was last updated. """ - since = self.data['agent-status']['since'] - # Juju gives us nanoseconds, but Python only supports microseconds - since = since[:26] - return datetime.strptime(since, "%Y-%m-%dT%H:%M:%S.%f") + return parse_date(self.safe_data['agent-status']['since']) @property def agent_status_message(self): """Get the agent status message. """ - return self.data['agent-status']['message'] + return self.safe_data['agent-status']['message'] @property def workload_status(self): """Returns the current workload status string. """ - return self.data['workload-status']['current'] + return self.safe_data['workload-status']['current'] @property def workload_status_since(self): """Get the time when the `workload_status` was last updated. """ - since = self.data['workload-status']['since'] - # Juju gives us nanoseconds, but Python only supports microseconds - since = since[:26] - return datetime.strptime(since, "%Y-%m-%dT%H:%M:%S.%f") + return parse_date(self.safe_data['workload-status']['since']) @property def workload_status_message(self): """Get the workload status message. """ - return self.data['workload-status']['message'] + return self.safe_data['workload-status']['message'] + + @property + def tag(self): + return 'unit-%s' % self.name.replace('/', '-') def add_storage(self, name, constraints=None): """Add unit storage dynamically. @@ -108,6 +107,9 @@ class Unit(model.ModelEntity): :param str command: The command to run :param int timeout: Time to wait before command is considered failed + Returns a tuple containing the stdout, stderr, and return code + from the command. + """ action = client.ActionFacade() action.connect(self.connection) @@ -115,23 +117,48 @@ class Unit(model.ModelEntity): log.debug( 'Running `%s` on %s', command, self.name) - # TODO this should return an Action - return await action.Run( + res = await action.Run( [], command, [], timeout, [self.name], ) + return await self.model.wait_for_action(res.results[0].action.tag) - def run_action(self, action_name, **params): - """Run action on this unit. + async def run_action(self, action_name, **params): + """Run an action on this unit. :param str action_name: Name of action to run :param \*\*params: Action parameters - - """ - pass + :returns: An `juju.action.Action` instance. + + Note that this only enqueues the action. You will need to call + ``action.wait()`` on the resulting `Action` instance if you wish + to block until the action is complete. + """ + action_facade = client.ActionFacade() + action_facade.connect(self.connection) + + log.debug('Starting action `%s` on %s', action_name, self.name) + + res = await action_facade.Enqueue([client.Action( + name=action_name, + parameters=params, + receiver=self.tag, + )]) + action = res.results[0].action + error = res.results[0].error + if error and error.code == 'not found': + raise ValueError('Action `%s` not found on %s' % (action_name, + self.name)) + elif error: + raise Exception('Unknown action error: %s' % error.serialize()) + action_id = action.tag[len('action-'):] + log.debug('Action started as %s', action_id) + # we mustn't use wait_for_action because that blocks until the + # action is complete, rather than just being in the model + return await self.model._wait_for_new('action', action_id) def scp( self, source_path, user=None, destination_path=None, proxy=False, @@ -174,3 +201,45 @@ class Unit(model.ModelEntity): """ pass + + async def is_leader_from_status(self): + """ + Check to see if this unit is the leader. Returns True if so, and + False if it is not, or if leadership does not make sense + (e.g., there is no leader in this application.) + + This method is a kluge that calls FullStatus in the + ClientFacade to get its information. Once + https://bugs.launchpad.net/juju/+bug/1643691 is resolved, we + should add a simple .is_leader property, and deprecate this + method. + + """ + app = self.name.split("/")[0] + + c = client.ClientFacade() + c.connect(self.model.connection) + + status = await c.FullStatus(None) + + # FullStatus may be more up to date than our model, and the + # unit may have gone away, or we may be doing something silly, + # like trying to fetch leadership for a subordinate, which + # will not be filed where we expect in the model. In those + # cases, we may simply return False, as a nonexistent or + # subordinate unit is not a leader. + if not status.applications.get(app): + return False + + if not status.applications[app].get('units'): + return False + + if not status.applications[app]['units'].get(self.name): + return False + + return status.applications[app]['units'][self.name].get('leader', + False) + + async def get_metrics(self): + metrics = await self.model.get_metrics(self.tag) + return metrics[self.name]