from . import model
from .client import client
+from .errors import JujuError
from .placement import parse as parse_placement
log = logging.getLogger(__name__)
"""Get the application status, as set by the charm's leader.
"""
- return self.data['status']['current']
+ return self.safe_data['status']['current']
@property
def status_message(self):
"""Get the application status message, as set by the charm's leader.
"""
- return self.data['status']['message']
+ return self.safe_data['status']['message']
@property
def tag(self):
If None, a new machine is provisioned.
"""
- app_facade = client.ApplicationFacade()
- app_facade.connect(self.connection)
+ app_facade = client.ApplicationFacade.from_connection(self.connection)
log.debug(
'Adding %s unit%s to %s',
result = await app_facade.AddUnits(
application=self.name,
- placement=[parse_placement(to)],
+ placement=parse_placement(to) if to else None,
num_units=count,
)
:param int value: Budget limit
"""
- pass
+ raise NotImplementedError()
def attach(self, resource_name, file_path):
"""Upload a file as a resource for this application.
:param str file_path: Path to the file to upload
"""
- pass
+ raise NotImplementedError()
def collect_metrics(self):
"""Collect metrics on this application.
"""
- pass
+ raise NotImplementedError()
async def destroy_relation(self, local_relation, remote_relation):
"""Remove a relation to another application.
if ':' not in local_relation:
local_relation = '{}:{}'.format(self.name, local_relation)
- app_facade = client.ApplicationFacade()
- app_facade.connect(self.connection)
+ app_facade = client.ApplicationFacade.from_connection(self.connection)
log.debug(
'Destroying relation %s <-> %s', local_relation, remote_relation)
"""Remove this application from the model.
"""
- app_facade = client.ApplicationFacade()
- app_facade.connect(self.connection)
+ app_facade = client.ApplicationFacade.from_connection(self.connection)
log.debug(
'Destroying %s', self.name)
"""Make this application publicly available over the network.
"""
- app_facade = client.ApplicationFacade()
- app_facade.connect(self.connection)
+ app_facade = client.ApplicationFacade.from_connection(self.connection)
log.debug(
'Exposing %s', self.name)
"""Return the configuration settings dict for this application.
"""
- app_facade = client.ApplicationFacade()
- app_facade.connect(self.connection)
+ app_facade = client.ApplicationFacade.from_connection(self.connection)
log.debug(
'Getting config for %s', self.name)
"""Return the machine constraints dict for this application.
"""
- app_facade = client.ApplicationFacade()
- app_facade.connect(self.connection)
+ app_facade = client.ApplicationFacade.from_connection(self.connection)
log.debug(
'Getting constraints for %s', self.name)
:param bool schema: Return the full action schema
"""
- pass
+ raise NotImplementedError()
def get_resources(self, details=False):
"""Return resources for this application.
unit
"""
- pass
+ raise NotImplementedError()
async def run(self, command, timeout=None):
"""Run command on all units for this application.
:param int timeout: Time to wait before command is considered failed
"""
- action = client.ActionFacade()
- action.connect(self.connection)
+ action = client.ActionFacade.from_connection(self.connection)
log.debug(
'Running `%s` on all units of %s', command, self.name)
"""
log.debug('Updating annotations on application %s', self.name)
- self.ann_facade = client.AnnotationsFacade()
- self.ann_facade.connect(self.connection)
+ self.ann_facade = client.AnnotationsFacade.from_connection(
+ self.connection)
ann = client.EntityAnnotations(
- entity=self.name,
+ entity=self.tag,
annotations=annotations,
)
return await self.ann_facade.Set([ann])
:param bool to_default: Set application options to default values
"""
- app_facade = client.ApplicationFacade()
- app_facade.connect(self.connection)
+ app_facade = client.ApplicationFacade.from_connection(self.connection)
log.debug(
'Setting config for %s: %s', self.name, config)
:param dict constraints: Dict of machine constraints
"""
- app_facade = client.ApplicationFacade()
- app_facade.connect(self.connection)
+ app_facade = client.ApplicationFacade.from_connection(self.connection)
log.debug(
'Setting constraints for %s: %s', self.name, constraints)
:param str info: Extra info message
"""
- pass
+ raise NotImplementedError()
def set_plan(self, plan_name):
"""Set the plan for this application, effective immediately.
:param str plan_name: Name of plan
"""
- pass
+ raise NotImplementedError()
async def unexpose(self):
"""Remove public availability over the network for this application.
"""
- app_facade = client.ApplicationFacade()
- app_facade.connect(self.connection)
+ app_facade = client.ApplicationFacade.from_connection(self.connection)
log.debug(
'Unexposing %s', self.name)
:param int allocation: The allocation to set
"""
- pass
+ raise NotImplementedError()
- def upgrade_charm(
+ async def upgrade_charm(
self, channel=None, force_series=False, force_units=False,
- path=None, resources=None, revision=-1, switch=None):
+ path=None, resources=None, revision=None, switch=None):
"""Upgrade the charm for this application.
:param str channel: Channel to use when getting the charm from the
:param str switch: Crossgrade charm url
"""
- pass
+ # TODO: Support local upgrades
+ if path is not None:
+ raise NotImplementedError("path option is not implemented")
+ if resources is not None:
+ raise NotImplementedError("resources option is not implemented")
+
+ if switch is not None and revision is not None:
+ raise ValueError("switch and revision are mutually exclusive")
+
+ client_facade = client.ClientFacade.from_connection(self.connection)
+ app_facade = client.ApplicationFacade.from_connection(self.connection)
+
+ if switch is not None:
+ charm_url = switch
+ if not charm_url.startswith('cs:'):
+ charm_url = 'cs:' + charm_url
+ else:
+ charm_url = self.data['charm-url']
+ charm_url = charm_url.rpartition('-')[0]
+ if revision is not None:
+ charm_url = "%s-%d" % (charm_url, revision)
+ else:
+ charmstore = self.model.charmstore
+ entity = await charmstore.entity(charm_url, channel=channel)
+ charm_url = entity['Id']
+
+ if charm_url == self.data['charm-url']:
+ raise JujuError('already running charm "%s"' % charm_url)
+
+ await client_facade.AddCharm(
+ url=charm_url,
+ channel=channel
+ )
+
+ await app_facade.SetCharm(
+ application=self.entity_id,
+ channel=channel,
+ charm_url=charm_url,
+ config_settings=None,
+ config_settings_yaml=None,
+ force_series=force_series,
+ force_units=force_units,
+ resource_ids=None,
+ storage_constraints=None
+ )
+
+ await self.model.block_until(
+ lambda: self.data['charm-url'] == charm_url
+ )
async def get_metrics(self):
+ """Get metrics for this application's units.
+
+ :return: Dictionary of unit_name:metrics
+
+ """
return await self.model.get_metrics(self.tag)
projects / osm / N2VC.git / blobdiff