-import asyncio
import logging
from datetime import datetime
"""
return self.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.
log.debug(
'Running `%s` on %s', command, self.name)
- action_status = asyncio.Queue(loop=self.model.loop)
- tag = None
-
- async def wait_for_tag():
- while tag is None:
- asyncio.sleep(0.1)
- return tag
-
- async def callback(delta, old, new, model):
- # Wait until we have something to report
- if not new:
- return
-
- # Verify that we have the the right action.
- tag = await wait_for_tag()
- if not new.id in tag:
- return
-
- # Wait until the action has completed, or errored out.
- if new.status not in ['completed', 'error']:
- return
-
- # Put the action in our queue, so that we can fetch it
- # with the await below.
- await action_status.put(new)
-
- self.model.add_observer(callback, 'action', None)
-
res = await action.Run(
[],
command,
timeout,
[self.name],
)
- tag = res.results[0].action.tag # Set the tag for our waiter above.
- ret = await action_status.get() # Wait for our callback to fire
- return (
- ret.results['Stdout'],
- ret.results['Stderr'],
- ret.results['Code']
- )
+ 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,
"""
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]