juju/unit.py

   1 import asyncio
   2 import logging
   3 from datetime import datetime
   4
   5 from . import model
   6 from .client import client
   7
   8 log = logging.getLogger(__name__)
   9
  10
  11 class Unit(model.ModelEntity):
  12     @property
  13     def agent_status(self):
  14         """Returns the current agent status string.
  15
  16         """
  17         return self.data['agent-status']['current']
  18
  19     @property
  20     def agent_status_since(self):
  21         """Get the time when the `agent_status` was last updated.
  22
  23         """
  24         since = self.data['agent-status']['since']
  25         # Juju gives us nanoseconds, but Python only supports microseconds
  26         since = since[:26]
  27         return datetime.strptime(since, "%Y-%m-%dT%H:%M:%S.%f")
  28
  29     @property
  30     def agent_status_message(self):
  31         """Get the agent status message.
  32
  33         """
  34         return self.data['agent-status']['message']
  35
  36     @property
  37     def workload_status(self):
  38         """Returns the current workload status string.
  39
  40         """
  41         return self.data['workload-status']['current']
  42
  43     @property
  44     def workload_status_since(self):
  45         """Get the time when the `workload_status` was last updated.
  46
  47         """
  48         since = self.data['workload-status']['since']
  49         # Juju gives us nanoseconds, but Python only supports microseconds
  50         since = since[:26]
  51         return datetime.strptime(since, "%Y-%m-%dT%H:%M:%S.%f")
  52
  53     @property
  54     def workload_status_message(self):
  55         """Get the workload status message.
  56
  57         """
  58         return self.data['workload-status']['message']
  59
  60     def add_storage(self, name, constraints=None):
  61         """Add unit storage dynamically.
  62
  63         :param str name: Storage name, as specified by the charm
  64         :param str constraints: Comma-separated list of constraints in the
  65             form 'POOL,COUNT,SIZE'
  66
  67         """
  68         pass
  69
  70     def collect_metrics(self):
  71         """Collect metrics on this unit.
  72
  73         """
  74         pass
  75
  76     async def destroy(self):
  77         """Destroy this unit.
  78
  79         """
  80         app_facade = client.ApplicationFacade()
  81         app_facade.connect(self.connection)
  82
  83         log.debug(
  84             'Destroying %s', self.name)
  85
  86         return await app_facade.DestroyUnits([self.name])
  87     remove = destroy
  88
  89     def get_resources(self, details=False):
  90         """Return resources for this unit.
  91
  92         :param bool details: Include detailed info about resources used by each
  93             unit
  94
  95         """
  96         pass
  97
  98     def resolved(self, retry=False):
  99         """Mark unit errors resolved.
 100
 101         :param bool retry: Re-execute failed hooks
 102
 103         """
 104         pass
 105
 106     async def run(self, command, timeout=None):
 107         """Run command on this unit.
 108
 109         :param str command: The command to run
 110         :param int timeout: Time to wait before command is considered failed
 111
 112         Returns a tuple containing the stdout, stderr, and return code
 113         from the command.
 114
 115         """
 116         action = client.ActionFacade()
 117         action.connect(self.connection)
 118
 119         log.debug(
 120             'Running `%s` on %s', command, self.name)
 121
 122         res = await action.Run(
 123             [],
 124             command,
 125             [],
 126             timeout,
 127             [self.name],
 128         )
 129         return await self.model.wait_for_action(res.results[0].action.tag)
 130
 131     def run_action(self, action_name, **params):
 132         """Run action on this unit.
 133
 134         :param str action_name: Name of action to run
 135         :param \*\*params: Action parameters
 136
 137         """
 138         pass
 139
 140     def scp(
 141             self, source_path, user=None, destination_path=None, proxy=False,
 142             scp_opts=None):
 143         """Transfer files to this unit.
 144
 145         :param str source_path: Path of file(s) to transfer
 146         :param str user: Remote username
 147         :param str destination_path: Destination of transferred files on
 148             remote machine
 149         :param bool proxy: Proxy through the Juju API server
 150         :param str scp_opts: Additional options to the `scp` command
 151
 152         """
 153         pass
 154
 155     def set_meter_status(self):
 156         """Set the meter status on this unit.
 157
 158         """
 159         pass
 160
 161     def ssh(
 162             self, command, user=None, proxy=False, ssh_opts=None):
 163         """Execute a command over SSH on this unit.
 164
 165         :param str command: Command to execute
 166         :param str user: Remote username
 167         :param bool proxy: Proxy through the Juju API server
 168         :param str ssh_opts: Additional options to the `ssh` command
 169
 170         """
 171         pass
 172
 173     def status_history(self, num=20, utc=False):
 174         """Get status history for this unit.
 175
 176         :param int num: Size of history backlog
 177         :param bool utc: Display time as UTC in RFC3339 format
 178
 179         """
 180         pass