X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=juju%2Funit.py;h=7a6378a2ba206661dbfb3bc2e6b17487d268dd79;hb=refs%2Ftags%2F0.4.0;hp=4b24331a54fad487e58eb4d0136b81a774894a28;hpb=3a10e9365e5946c806219b870a464983ab4d879c;p=osm%2FN2VC.git diff --git a/juju/unit.py b/juju/unit.py index 4b24331..7a6378a 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. @@ -64,20 +63,19 @@ class Unit(model.ModelEntity): form 'POOL,COUNT,SIZE' """ - pass + raise NotImplementedError() def collect_metrics(self): """Collect metrics on this unit. """ - pass + raise NotImplementedError() async def destroy(self): """Destroy this unit. """ - app_facade = client.ApplicationFacade() - app_facade.connect(self.connection) + app_facade = client.ApplicationFacade.from_connection(self.connection) log.debug( 'Destroying %s', self.name) @@ -92,7 +90,7 @@ class Unit(model.ModelEntity): unit """ - pass + raise NotImplementedError() def resolved(self, retry=False): """Mark unit errors resolved. @@ -100,37 +98,63 @@ class Unit(model.ModelEntity): :param bool retry: Re-execute failed hooks """ - pass + raise NotImplementedError() async def run(self, command, timeout=None): """Run command on this unit. :param str command: The command to run :param int timeout: Time to wait before command is considered failed + :returns: A :class:`juju.action.Action` instance. """ - action = client.ActionFacade() - action.connect(self.connection) + action = client.ActionFacade.from_connection(self.connection) log.debug( 'Running `%s` on %s', command, self.name) - 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: A :class:`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.from_connection(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, @@ -145,13 +169,13 @@ class Unit(model.ModelEntity): :param str scp_opts: Additional options to the `scp` command """ - pass + raise NotImplementedError() def set_meter_status(self): """Set the meter status on this unit. """ - pass + raise NotImplementedError() def ssh( self, command, user=None, proxy=False, ssh_opts=None): @@ -163,7 +187,7 @@ class Unit(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 unit. @@ -172,4 +196,50 @@ class Unit(model.ModelEntity): :param bool utc: Display time as UTC in RFC3339 format """ - pass + raise NotImplementedError() + + 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.from_connection(self.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): + """Get metrics for the unit. + + :return: Dictionary of metrics for this unit. + + """ + metrics = await self.model.get_metrics(self.tag) + return metrics[self.name]