self.connected = connected
self.connection = model.connection
+ def __repr__(self):
+ return '<{} entity_id="{}">'.format(type(self).__name__,
+ self.entity_id)
+
def __getattr__(self, name):
"""Fetch object attributes from the underlying data dict held in the
model.
"""
- if self.data is None:
- raise DeadEntityException(
- "Entity {}:{} is dead - its attributes can no longer be "
- "accessed. Use the .previous() method on this object to get "
- "a copy of the object at its previous state.".format(
- self.entity_type, self.entity_id))
- return self.data[name]
+ return self.safe_data[name]
def __bool__(self):
return bool(self.data)
return self.model.state.entity_data(
self.entity_type, self.entity_id, self._history_index)
+ @property
+ def safe_data(self):
+ """The data dictionary for this entity.
+
+ If this `ModelEntity` points to the dead state, it will
+ raise `DeadEntityException`.
+
+ """
+ if self.data is None:
+ raise DeadEntityException(
+ "Entity {}:{} is dead - its attributes can no longer be "
+ "accessed. Use the .previous() method on this object to get "
+ "a copy of the object at its previous state.".format(
+ self.entity_type, self.entity_id))
+ return self.data
+
def previous(self):
"""Return a copy of this object as was at its previous state in
history.
lambda: len(self.machines) == 0
)
- async def block_until(self, *conditions, timeout=None):
+ async def block_until(self, *conditions, timeout=None, wait_period=0.5):
"""Return only after all conditions are true.
"""
async def _block():
while not all(c() for c in conditions):
- await asyncio.sleep(0)
+ await asyncio.sleep(wait_period)
await asyncio.wait_for(_block(), timeout)
@property
"""Register an "on-model-change" callback
Once the model is connected, ``callable_``
- will be called each time the model changes. callable_ should
+ will be called each time the model changes. ``callable_`` should
be Awaitable and accept the following positional arguments:
delta - An instance of :class:`juju.delta.EntityDelta`
model - The :class:`Model` itself.
Events for which ``callable_`` is called can be specified by passing
- entity_type, action, and/or id_ filter criteria, e.g.:
+ entity_type, action, and/or entitiy_id filter criteria, e.g.::
add_observer(
- myfunc, entity_type='application', action='add', id_='ubuntu')
+ myfunc,
+ entity_type='application', action='add', entity_id='ubuntu')
For more complex filtering conditions, pass a predicate function. It
will be called with a delta as its only argument. If the predicate
- function returns True, the callable_ will be called.
+ function returns True, the ``callable_`` will be called.
"""
observer = _Observer(
pass
async def deploy(
- self, entity_url, service_name=None, bind=None, budget=None,
+ self, entity_url, application_name=None, bind=None, budget=None,
channel=None, config=None, constraints=None, force=False,
num_units=1, plan=None, resources=None, series=None, storage=None,
to=None):
"""Deploy a new service or bundle.
:param str entity_url: Charm or bundle url
- :param str service_name: Name to give the service
+ :param str application_name: Name to give the service
:param dict bind: <charm endpoint>:<network space> pairs
:param dict budget: <budget name>:<limit> pairs
:param str channel: Charm store channel from which to retrieve
TODO::
- - service_name is required; fill this in automatically if not
+ - application_name is required; fill this in automatically if not
provided by caller
- series is required; how do we pick a default?
# haven't made it yet we'll need to wait on them to be added
await asyncio.gather(*[
asyncio.ensure_future(
- self.model._wait_for_new('application', app_name))
+ self._wait_for_new('application', app_name))
for app_name in pending_apps
])
return [app for name, app in self.applications.items()
await client_facade.AddCharm(channel, entity_id)
app = client.ApplicationDeploy(
- application=service_name,
+ application=application_name,
channel=channel,
charm_url=entity_id,
config=config,
)
await app_facade.Deploy([app])
- return await self._wait_for_new('application', service_name)
+ return await self._wait_for_new('application', application_name)
def destroy(self):
"""Terminate all machines and resources for this model.
Keys include:
series: string specifying the machine OS series.
+
constraints: string holding machine constraints, if any. We'll
parse this into the json friendly dict that the juju api
expects.
+
container_type: string holding the type of the container (for
instance ""lxc" or kvm"). It is not specified for top level
machines.
+
parent_id: string holding a placeholder pointing to another
machine change or to a unit change. This value is only
specified in the case this machine is a container, in
which case also ContainerType is set.
+
"""
params = params or {}