class Action(Type):
- _toSchema = {'name': 'name', 'receiver': 'receiver', 'tag': 'tag', 'parameters': 'parameters'}
- _toPy = {'name': 'name', 'receiver': 'receiver', 'tag': 'tag', 'parameters': 'parameters'}
+ _toSchema = {'name': 'name', 'parameters': 'parameters', 'receiver': 'receiver', 'tag': 'tag'}
+ _toPy = {'name': 'name', 'parameters': 'parameters', 'receiver': 'receiver', 'tag': 'tag'}
def __init__(self, name=None, parameters=None, receiver=None, tag=None):
'''
name : str
class ActionResult(Type):
- _toSchema = {'started': 'started', 'error': 'error', 'message': 'message', 'status': 'status', 'enqueued': 'enqueued', 'action': 'action', 'completed': 'completed', 'output': 'output'}
- _toPy = {'started': 'started', 'error': 'error', 'message': 'message', 'status': 'status', 'enqueued': 'enqueued', 'action': 'action', 'completed': 'completed', 'output': 'output'}
+ _toSchema = {'action': 'action', 'completed': 'completed', 'enqueued': 'enqueued', 'error': 'error', 'message': 'message', 'output': 'output', 'started': 'started', 'status': 'status'}
+ _toPy = {'action': 'action', 'completed': 'completed', 'enqueued': 'enqueued', 'error': 'error', 'message': 'message', 'output': 'output', 'started': 'started', 'status': 'status'}
def __init__(self, action=None, completed=None, enqueued=None, error=None, message=None, output=None, started=None, status=None):
'''
action : Action
class ActionsByName(Type):
- _toSchema = {'name': 'name', 'actions': 'actions', 'error': 'error'}
- _toPy = {'name': 'name', 'actions': 'actions', 'error': 'error'}
+ _toSchema = {'actions': 'actions', 'error': 'error', 'name': 'name'}
+ _toPy = {'actions': 'actions', 'error': 'error', 'name': 'name'}
def __init__(self, actions=None, error=None, name=None):
'''
actions : typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
class ActionsByReceiver(Type):
- _toSchema = {'receiver': 'receiver', 'actions': 'actions', 'error': 'error'}
- _toPy = {'receiver': 'receiver', 'actions': 'actions', 'error': 'error'}
+ _toSchema = {'actions': 'actions', 'error': 'error', 'receiver': 'receiver'}
+ _toPy = {'actions': 'actions', 'error': 'error', 'receiver': 'receiver'}
def __init__(self, actions=None, error=None, receiver=None):
'''
actions : typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
class ApplicationCharmActionsResult(Type):
- _toSchema = {'error': 'error', 'actions': 'actions', 'application_tag': 'application-tag'}
- _toPy = {'application-tag': 'application_tag', 'actions': 'actions', 'error': 'error'}
+ _toSchema = {'actions': 'actions', 'application_tag': 'application-tag', 'error': 'error'}
+ _toPy = {'actions': 'actions', 'application-tag': 'application_tag', 'error': 'error'}
def __init__(self, actions=None, application_tag=None, error=None):
'''
actions : typing.Mapping<~KT, +VT_co>[str, ~ActionSpec]<~ActionSpec>
class Error(Type):
- _toSchema = {'info': 'info', 'code': 'code', 'message': 'message'}
- _toPy = {'info': 'info', 'code': 'code', 'message': 'message'}
+ _toSchema = {'code': 'code', 'info': 'info', 'message': 'message'}
+ _toPy = {'code': 'code', 'info': 'info', 'message': 'message'}
def __init__(self, code=None, info=None, message=None):
'''
code : str
class ErrorInfo(Type):
_toSchema = {'macaroon': 'macaroon', 'macaroon_path': 'macaroon-path'}
- _toPy = {'macaroon-path': 'macaroon_path', 'macaroon': 'macaroon'}
+ _toPy = {'macaroon': 'macaroon', 'macaroon-path': 'macaroon_path'}
def __init__(self, macaroon=None, macaroon_path=None):
'''
macaroon : Macaroon
class RunParams(Type):
- _toSchema = {'commands': 'commands', 'machines': 'machines', 'units': 'units', 'applications': 'applications', 'timeout': 'timeout'}
- _toPy = {'commands': 'commands', 'machines': 'machines', 'units': 'units', 'applications': 'applications', 'timeout': 'timeout'}
+ _toSchema = {'applications': 'applications', 'commands': 'commands', 'machines': 'machines', 'timeout': 'timeout', 'units': 'units'}
+ _toPy = {'applications': 'applications', 'commands': 'commands', 'machines': 'machines', 'timeout': 'timeout', 'units': 'units'}
def __init__(self, applications=None, commands=None, machines=None, timeout=None, units=None):
'''
applications : typing.Sequence<+T_co>[str]
class AgentGetEntitiesResult(Type):
- _toSchema = {'life': 'life', 'error': 'error', 'jobs': 'jobs', 'container_type': 'container-type'}
- _toPy = {'life': 'life', 'container-type': 'container_type', 'jobs': 'jobs', 'error': 'error'}
+ _toSchema = {'container_type': 'container-type', 'error': 'error', 'jobs': 'jobs', 'life': 'life'}
+ _toPy = {'container-type': 'container_type', 'error': 'error', 'jobs': 'jobs', 'life': 'life'}
def __init__(self, container_type=None, error=None, jobs=None, life=None):
'''
container_type : str
class CloudCredential(Type):
- _toSchema = {'auth_type': 'auth-type', 'attrs': 'attrs', 'redacted': 'redacted'}
- _toPy = {'auth-type': 'auth_type', 'attrs': 'attrs', 'redacted': 'redacted'}
+ _toSchema = {'attrs': 'attrs', 'auth_type': 'auth-type', 'redacted': 'redacted'}
+ _toPy = {'attrs': 'attrs', 'auth-type': 'auth_type', 'redacted': 'redacted'}
def __init__(self, attrs=None, auth_type=None, redacted=None):
'''
attrs : typing.Mapping<~KT, +VT_co>[str, str]
class CloudSpec(Type):
- _toSchema = {'type_': 'type', 'identity_endpoint': 'identity-endpoint', 'storage_endpoint': 'storage-endpoint', 'region': 'region', 'name': 'name', 'endpoint': 'endpoint', 'credential': 'credential'}
- _toPy = {'region': 'region', 'name': 'name', 'type': 'type_', 'identity-endpoint': 'identity_endpoint', 'endpoint': 'endpoint', 'credential': 'credential', 'storage-endpoint': 'storage_endpoint'}
+ _toSchema = {'credential': 'credential', 'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'name': 'name', 'region': 'region', 'storage_endpoint': 'storage-endpoint', 'type_': 'type'}
+ _toPy = {'credential': 'credential', 'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'name': 'name', 'region': 'region', 'storage-endpoint': 'storage_endpoint', 'type': 'type_'}
def __init__(self, credential=None, endpoint=None, identity_endpoint=None, name=None, region=None, storage_endpoint=None, type_=None):
'''
credential : CloudCredential
class CloudSpecResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class EntityPassword(Type):
- _toSchema = {'tag': 'tag', 'password': 'password'}
- _toPy = {'tag': 'tag', 'password': 'password'}
+ _toSchema = {'password': 'password', 'tag': 'tag'}
+ _toPy = {'password': 'password', 'tag': 'tag'}
def __init__(self, password=None, tag=None):
'''
password : str
class ErrorResult(Type):
- _toSchema = {'info': 'info', 'code': 'code', 'message': 'message'}
- _toPy = {'info': 'info', 'code': 'code', 'message': 'message'}
- def __init__(self, code=None, info=None, message=None):
+ _toSchema = {'error': 'error'}
+ _toPy = {'error': 'error'}
+ def __init__(self, error=None):
'''
- code : str
- info : ErrorInfo
- message : str
+ error : Error
'''
- self.code = code
- self.info = ErrorInfo.from_json(info) if info else None
- self.message = message
+ self.error = Error.from_json(error) if error else None
class ErrorResults(Type):
self.config = config
+class ModelTag(Type):
+ _toSchema = {}
+ _toPy = {}
+ def __init__(self):
+ '''
+
+ '''
+ pass
+
+
class NotifyWatchResult(Type):
- _toSchema = {'notifywatcherid': 'NotifyWatcherId', 'error': 'error'}
+ _toSchema = {'error': 'error', 'notifywatcherid': 'NotifyWatcherId'}
_toPy = {'NotifyWatcherId': 'notifywatcherid', 'error': 'error'}
def __init__(self, notifywatcherid=None, error=None):
'''
self.error = Error.from_json(error) if error else None
+class NotifyWatchResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
+ '''
+ self.results = [NotifyWatchResult.from_json(o) for o in results or []]
+
+
class StateServingInfo(Type):
- _toSchema = {'state_port': 'state-port', 'system_identity': 'system-identity', 'api_port': 'api-port', 'cert': 'cert', 'shared_secret': 'shared-secret', 'private_key': 'private-key', 'ca_private_key': 'ca-private-key'}
- _toPy = {'shared-secret': 'shared_secret', 'state-port': 'state_port', 'cert': 'cert', 'ca-private-key': 'ca_private_key', 'api-port': 'api_port', 'system-identity': 'system_identity', 'private-key': 'private_key'}
+ _toSchema = {'api_port': 'api-port', 'ca_private_key': 'ca-private-key', 'cert': 'cert', 'private_key': 'private-key', 'shared_secret': 'shared-secret', 'state_port': 'state-port', 'system_identity': 'system-identity'}
+ _toPy = {'api-port': 'api_port', 'ca-private-key': 'ca_private_key', 'cert': 'cert', 'private-key': 'private_key', 'shared-secret': 'shared_secret', 'state-port': 'state_port', 'system-identity': 'system_identity'}
def __init__(self, api_port=None, ca_private_key=None, cert=None, private_key=None, shared_secret=None, state_port=None, system_identity=None):
'''
api_port : int
class AnnotationsGetResult(Type):
- _toSchema = {'entity': 'entity', 'annotations': 'annotations', 'error': 'error'}
- _toPy = {'entity': 'entity', 'annotations': 'annotations', 'error': 'error'}
+ _toSchema = {'annotations': 'annotations', 'entity': 'entity', 'error': 'error'}
+ _toPy = {'annotations': 'annotations', 'entity': 'entity', 'error': 'error'}
def __init__(self, annotations=None, entity=None, error=None):
'''
annotations : typing.Mapping<~KT, +VT_co>[str, str]
class EntityAnnotations(Type):
- _toSchema = {'entity': 'entity', 'annotations': 'annotations'}
- _toPy = {'entity': 'entity', 'annotations': 'annotations'}
+ _toSchema = {'annotations': 'annotations', 'entity': 'entity'}
+ _toPy = {'annotations': 'annotations', 'entity': 'entity'}
def __init__(self, annotations=None, entity=None):
'''
annotations : typing.Mapping<~KT, +VT_co>[str, str]
class AddApplicationUnits(Type):
- _toSchema = {'application': 'application', 'placement': 'placement', 'num_units': 'num-units'}
- _toPy = {'application': 'application', 'placement': 'placement', 'num-units': 'num_units'}
+ _toSchema = {'application': 'application', 'num_units': 'num-units', 'placement': 'placement'}
+ _toPy = {'application': 'application', 'num-units': 'num_units', 'placement': 'placement'}
def __init__(self, application=None, num_units=None, placement=None):
'''
application : str
class ApplicationDeploy(Type):
- _toSchema = {'application': 'application', 'charm_url': 'charm-url', 'channel': 'channel', 'resources': 'resources', 'placement': 'placement', 'config_yaml': 'config-yaml', 'config': 'config', 'constraints': 'constraints', 'num_units': 'num-units', 'storage': 'storage', 'endpoint_bindings': 'endpoint-bindings', 'series': 'series'}
- _toPy = {'application': 'application', 'num-units': 'num_units', 'channel': 'channel', 'resources': 'resources', 'placement': 'placement', 'endpoint-bindings': 'endpoint_bindings', 'config': 'config', 'constraints': 'constraints', 'series': 'series', 'storage': 'storage', 'charm-url': 'charm_url', 'config-yaml': 'config_yaml'}
+ _toSchema = {'application': 'application', 'channel': 'channel', 'charm_url': 'charm-url', 'config': 'config', 'config_yaml': 'config-yaml', 'constraints': 'constraints', 'endpoint_bindings': 'endpoint-bindings', 'num_units': 'num-units', 'placement': 'placement', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
+ _toPy = {'application': 'application', 'channel': 'channel', 'charm-url': 'charm_url', 'config': 'config', 'config-yaml': 'config_yaml', 'constraints': 'constraints', 'endpoint-bindings': 'endpoint_bindings', 'num-units': 'num_units', 'placement': 'placement', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
def __init__(self, application=None, channel=None, charm_url=None, config=None, config_yaml=None, constraints=None, endpoint_bindings=None, num_units=None, placement=None, resources=None, series=None, storage=None):
'''
application : str
class ApplicationGetResults(Type):
- _toSchema = {'application': 'application', 'config': 'config', 'charm': 'charm', 'constraints': 'constraints', 'series': 'series'}
- _toPy = {'application': 'application', 'config': 'config', 'charm': 'charm', 'constraints': 'constraints', 'series': 'series'}
+ _toSchema = {'application': 'application', 'charm': 'charm', 'config': 'config', 'constraints': 'constraints', 'series': 'series'}
+ _toPy = {'application': 'application', 'charm': 'charm', 'config': 'config', 'constraints': 'constraints', 'series': 'series'}
def __init__(self, application=None, charm=None, config=None, constraints=None, series=None):
'''
application : str
class ApplicationSetCharm(Type):
- _toSchema = {'application': 'application', 'charm_url': 'charm-url', 'channel': 'channel', 'force_units': 'force-units', 'force_series': 'force-series', 'resource_ids': 'resource-ids'}
- _toPy = {'application': 'application', 'force-units': 'force_units', 'channel': 'channel', 'charm-url': 'charm_url', 'force-series': 'force_series', 'resource-ids': 'resource_ids'}
- def __init__(self, application=None, channel=None, charm_url=None, force_series=None, force_units=None, resource_ids=None):
+ _toSchema = {'application': 'application', 'channel': 'channel', 'charm_url': 'charm-url', 'config_settings': 'config-settings', 'config_settings_yaml': 'config-settings-yaml', 'force_series': 'force-series', 'force_units': 'force-units', 'resource_ids': 'resource-ids', 'storage_constraints': 'storage-constraints'}
+ _toPy = {'application': 'application', 'channel': 'channel', 'charm-url': 'charm_url', 'config-settings': 'config_settings', 'config-settings-yaml': 'config_settings_yaml', 'force-series': 'force_series', 'force-units': 'force_units', 'resource-ids': 'resource_ids', 'storage-constraints': 'storage_constraints'}
+ def __init__(self, application=None, channel=None, charm_url=None, config_settings=None, config_settings_yaml=None, force_series=None, force_units=None, resource_ids=None, storage_constraints=None):
'''
application : str
channel : str
charm_url : str
+ config_settings : typing.Mapping<~KT, +VT_co>[str, str]
+ config_settings_yaml : str
force_series : bool
force_units : bool
resource_ids : typing.Mapping<~KT, +VT_co>[str, str]
+ storage_constraints : typing.Mapping<~KT, +VT_co>[str, ~StorageConstraints]<~StorageConstraints>
'''
self.application = application
self.channel = channel
self.charm_url = charm_url
+ self.config_settings = config_settings
+ self.config_settings_yaml = config_settings_yaml
self.force_series = force_series
self.force_units = force_units
self.resource_ids = resource_ids
+ self.storage_constraints = storage_constraints
class ApplicationUnexpose(Type):
class ApplicationUpdate(Type):
- _toSchema = {'application': 'application', 'charm_url': 'charm-url', 'constraints': 'constraints', 'settings_yaml': 'settings-yaml', 'min_units': 'min-units', 'settings': 'settings', 'force_series': 'force-series', 'force_charm_url': 'force-charm-url'}
- _toPy = {'application': 'application', 'constraints': 'constraints', 'settings-yaml': 'settings_yaml', 'min-units': 'min_units', 'charm-url': 'charm_url', 'force-series': 'force_series', 'settings': 'settings', 'force-charm-url': 'force_charm_url'}
+ _toSchema = {'application': 'application', 'charm_url': 'charm-url', 'constraints': 'constraints', 'force_charm_url': 'force-charm-url', 'force_series': 'force-series', 'min_units': 'min-units', 'settings': 'settings', 'settings_yaml': 'settings-yaml'}
+ _toPy = {'application': 'application', 'charm-url': 'charm_url', 'constraints': 'constraints', 'force-charm-url': 'force_charm_url', 'force-series': 'force_series', 'min-units': 'min_units', 'settings': 'settings', 'settings-yaml': 'settings_yaml'}
def __init__(self, application=None, charm_url=None, constraints=None, force_charm_url=None, force_series=None, min_units=None, settings=None, settings_yaml=None):
'''
application : str
class CharmRelation(Type):
- _toSchema = {'limit': 'limit', 'role': 'role', 'scope': 'scope', 'optional': 'optional', 'name': 'name', 'interface': 'interface'}
- _toPy = {'limit': 'limit', 'role': 'role', 'scope': 'scope', 'optional': 'optional', 'name': 'name', 'interface': 'interface'}
+ _toSchema = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'optional': 'optional', 'role': 'role', 'scope': 'scope'}
+ _toPy = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'optional': 'optional', 'role': 'role', 'scope': 'scope'}
def __init__(self, interface=None, limit=None, name=None, optional=None, role=None, scope=None):
'''
interface : str
class Constraints(Type):
- _toSchema = {'size': 'Size', 'pool': 'Pool', 'count': 'Count'}
- _toPy = {'Size': 'size', 'Count': 'count', 'Pool': 'pool'}
+ _toSchema = {'count': 'Count', 'pool': 'Pool', 'size': 'Size'}
+ _toPy = {'Count': 'count', 'Pool': 'pool', 'Size': 'size'}
def __init__(self, count=None, pool=None, size=None):
'''
count : int
class GetConstraintsResults(Type):
- _toSchema = {'cpu_power': 'cpu-power', 'instance_type': 'instance-type', 'tags': 'tags', 'virt_type': 'virt-type', 'arch': 'arch', 'container': 'container', 'root_disk': 'root-disk', 'mem': 'mem', 'cpu_cores': 'cpu-cores', 'spaces': 'spaces'}
- _toPy = {'virt-type': 'virt_type', 'cpu-power': 'cpu_power', 'container': 'container', 'cpu-cores': 'cpu_cores', 'arch': 'arch', 'tags': 'tags', 'mem': 'mem', 'spaces': 'spaces', 'instance-type': 'instance_type', 'root-disk': 'root_disk'}
- def __init__(self, arch=None, container=None, cpu_cores=None, cpu_power=None, instance_type=None, mem=None, root_disk=None, spaces=None, tags=None, virt_type=None):
+ _toSchema = {'constraints': 'constraints'}
+ _toPy = {'constraints': 'constraints'}
+ def __init__(self, constraints=None):
'''
- arch : str
- container : str
- cpu_cores : int
- cpu_power : int
- instance_type : str
- mem : int
- root_disk : int
- spaces : typing.Sequence<+T_co>[str]
- tags : typing.Sequence<+T_co>[str]
- virt_type : str
+ constraints : Value
'''
- self.arch = arch
- self.container = container
- self.cpu_cores = cpu_cores
- self.cpu_power = cpu_power
- self.instance_type = instance_type
- self.mem = mem
- self.root_disk = root_disk
- self.spaces = spaces
- self.tags = tags
- self.virt_type = virt_type
+ self.constraints = Value.from_json(constraints) if constraints else None
class Placement(Type):
self.constraints = Value.from_json(constraints) if constraints else None
+class StorageConstraints(Type):
+ _toSchema = {'count': 'count', 'pool': 'pool', 'size': 'size'}
+ _toPy = {'count': 'count', 'pool': 'pool', 'size': 'size'}
+ def __init__(self, count=None, pool=None, size=None):
+ '''
+ count : int
+ pool : str
+ size : int
+ '''
+ self.count = count
+ self.pool = pool
+ self.size = size
+
+
class StringResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class Value(Type):
- _toSchema = {'cpu_power': 'cpu-power', 'instance_type': 'instance-type', 'tags': 'tags', 'virt_type': 'virt-type', 'arch': 'arch', 'container': 'container', 'root_disk': 'root-disk', 'mem': 'mem', 'cpu_cores': 'cpu-cores', 'spaces': 'spaces'}
- _toPy = {'virt-type': 'virt_type', 'cpu-power': 'cpu_power', 'container': 'container', 'cpu-cores': 'cpu_cores', 'arch': 'arch', 'tags': 'tags', 'mem': 'mem', 'spaces': 'spaces', 'instance-type': 'instance_type', 'root-disk': 'root_disk'}
- def __init__(self, arch=None, container=None, cpu_cores=None, cpu_power=None, instance_type=None, mem=None, root_disk=None, spaces=None, tags=None, virt_type=None):
+ _toSchema = {'arch': 'arch', 'container': 'container', 'cores': 'cores', 'cpu_power': 'cpu-power', 'instance_type': 'instance-type', 'mem': 'mem', 'root_disk': 'root-disk', 'spaces': 'spaces', 'tags': 'tags', 'virt_type': 'virt-type'}
+ _toPy = {'arch': 'arch', 'container': 'container', 'cores': 'cores', 'cpu-power': 'cpu_power', 'instance-type': 'instance_type', 'mem': 'mem', 'root-disk': 'root_disk', 'spaces': 'spaces', 'tags': 'tags', 'virt-type': 'virt_type'}
+ def __init__(self, arch=None, container=None, cores=None, cpu_power=None, instance_type=None, mem=None, root_disk=None, spaces=None, tags=None, virt_type=None):
'''
arch : str
container : str
- cpu_cores : int
+ cores : int
cpu_power : int
instance_type : str
mem : int
'''
self.arch = arch
self.container = container
- self.cpu_cores = cpu_cores
+ self.cores = cores
self.cpu_power = cpu_power
self.instance_type = instance_type
self.mem = mem
self.virt_type = virt_type
+class ApplicationRelationsChange(Type):
+ _toSchema = {'changed': 'changed', 'removed': 'removed'}
+ _toPy = {'changed': 'changed', 'removed': 'removed'}
+ def __init__(self, changed=None, removed=None):
+ '''
+ changed : typing.Sequence<+T_co>[~RelationChange]<~RelationChange>
+ removed : typing.Sequence<+T_co>[int]
+ '''
+ self.changed = [RelationChange.from_json(o) for o in changed or []]
+ self.removed = removed
+
+
+class ApplicationRelationsWatchResult(Type):
+ _toSchema = {'applicationrelationswatcherid': 'ApplicationRelationsWatcherId', 'changes': 'changes', 'error': 'error'}
+ _toPy = {'ApplicationRelationsWatcherId': 'applicationrelationswatcherid', 'changes': 'changes', 'error': 'error'}
+ def __init__(self, applicationrelationswatcherid=None, changes=None, error=None):
+ '''
+ applicationrelationswatcherid : str
+ changes : ApplicationRelationsChange
+ error : Error
+ '''
+ self.applicationrelationswatcherid = applicationrelationswatcherid
+ self.changes = ApplicationRelationsChange.from_json(changes) if changes else None
+ self.error = Error.from_json(error) if error else None
+
+
+class RelationChange(Type):
+ _toSchema = {'changedunits': 'changedunits', 'departedunits': 'departedunits', 'id_': 'id', 'life': 'life'}
+ _toPy = {'changedunits': 'changedunits', 'departedunits': 'departedunits', 'id': 'id_', 'life': 'life'}
+ def __init__(self, changedunits=None, departedunits=None, id_=None, life=None):
+ '''
+ changedunits : typing.Mapping<~KT, +VT_co>[str, ~RelationUnitChange]<~RelationUnitChange>
+ departedunits : typing.Sequence<+T_co>[str]
+ id_ : int
+ life : str
+ '''
+ self.changedunits = changedunits
+ self.departedunits = departedunits
+ self.id_ = id_
+ self.life = life
+
+
+class RelationUnitChange(Type):
+ _toSchema = {'settings': 'settings'}
+ _toPy = {'settings': 'settings'}
+ def __init__(self, settings=None):
+ '''
+ settings : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ '''
+ self.settings = settings
+
+
class StringsWatchResult(Type):
- _toSchema = {'changes': 'changes', 'watcher_id': 'watcher-id', 'error': 'error'}
- _toPy = {'watcher-id': 'watcher_id', 'changes': 'changes', 'error': 'error'}
+ _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
+ _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
def __init__(self, changes=None, error=None, watcher_id=None):
'''
changes : typing.Sequence<+T_co>[str]
class BackupsMetadataResult(Type):
- _toSchema = {'ca_private_key': 'ca-private-key', 'size': 'size', 'started': 'started', 'id_': 'id', 'checksum': 'checksum', 'finished': 'finished', 'hostname': 'hostname', 'stored': 'stored', 'series': 'series', 'machine': 'machine', 'notes': 'notes', 'ca_cert': 'ca-cert', 'checksum_format': 'checksum-format', 'model': 'model', 'version': 'version'}
- _toPy = {'started': 'started', 'size': 'size', 'ca-cert': 'ca_cert', 'ca-private-key': 'ca_private_key', 'checksum': 'checksum', 'machine': 'machine', 'finished': 'finished', 'hostname': 'hostname', 'stored': 'stored', 'series': 'series', 'notes': 'notes', 'id': 'id_', 'checksum-format': 'checksum_format', 'model': 'model', 'version': 'version'}
+ _toSchema = {'ca_cert': 'ca-cert', 'ca_private_key': 'ca-private-key', 'checksum': 'checksum', 'checksum_format': 'checksum-format', 'finished': 'finished', 'hostname': 'hostname', 'id_': 'id', 'machine': 'machine', 'model': 'model', 'notes': 'notes', 'series': 'series', 'size': 'size', 'started': 'started', 'stored': 'stored', 'version': 'version'}
+ _toPy = {'ca-cert': 'ca_cert', 'ca-private-key': 'ca_private_key', 'checksum': 'checksum', 'checksum-format': 'checksum_format', 'finished': 'finished', 'hostname': 'hostname', 'id': 'id_', 'machine': 'machine', 'model': 'model', 'notes': 'notes', 'series': 'series', 'size': 'size', 'started': 'started', 'stored': 'stored', 'version': 'version'}
def __init__(self, ca_cert=None, ca_private_key=None, checksum=None, checksum_format=None, finished=None, hostname=None, id_=None, machine=None, model=None, notes=None, series=None, size=None, started=None, stored=None, version=None):
'''
ca_cert : str
class Number(Type):
- _toSchema = {'build': 'Build', 'patch': 'Patch', 'tag': 'Tag', 'minor': 'Minor', 'major': 'Major'}
- _toPy = {'Tag': 'tag', 'Major': 'major', 'Patch': 'patch', 'Minor': 'minor', 'Build': 'build'}
+ _toSchema = {'build': 'Build', 'major': 'Major', 'minor': 'Minor', 'patch': 'Patch', 'tag': 'Tag'}
+ _toPy = {'Build': 'build', 'Major': 'major', 'Minor': 'minor', 'Patch': 'patch', 'Tag': 'tag'}
def __init__(self, build=None, major=None, minor=None, patch=None, tag=None):
'''
build : int
class Block(Type):
- _toSchema = {'tag': 'tag', 'type_': 'type', 'id_': 'id', 'message': 'message'}
- _toPy = {'type': 'type_', 'id': 'id_', 'tag': 'tag', 'message': 'message'}
+ _toSchema = {'id_': 'id', 'message': 'message', 'tag': 'tag', 'type_': 'type'}
+ _toPy = {'id': 'id_', 'message': 'message', 'tag': 'tag', 'type': 'type_'}
def __init__(self, id_=None, message=None, tag=None, type_=None):
'''
id_ : str
class BlockResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class BlockSwitchParams(Type):
- _toSchema = {'type_': 'type', 'message': 'message'}
- _toPy = {'type': 'type_', 'message': 'message'}
+ _toSchema = {'message': 'message', 'type_': 'type'}
+ _toPy = {'message': 'message', 'type': 'type_'}
def __init__(self, message=None, type_=None):
'''
message : str
self.type_ = type_
+class BundleChange(Type):
+ _toSchema = {'args': 'args', 'id_': 'id', 'method': 'method', 'requires': 'requires'}
+ _toPy = {'args': 'args', 'id': 'id_', 'method': 'method', 'requires': 'requires'}
+ def __init__(self, args=None, id_=None, method=None, requires=None):
+ '''
+ args : typing.Sequence<+T_co>[typing.Any]
+ id_ : str
+ method : str
+ requires : typing.Sequence<+T_co>[str]
+ '''
+ self.args = args
+ self.id_ = id_
+ self.method = method
+ self.requires = requires
+
+
+class BundleChangesParams(Type):
+ _toSchema = {'yaml': 'yaml'}
+ _toPy = {'yaml': 'yaml'}
+ def __init__(self, yaml=None):
+ '''
+ yaml : str
+ '''
+ self.yaml = yaml
+
+
+class BundleChangesResults(Type):
+ _toSchema = {'changes': 'changes', 'errors': 'errors'}
+ _toPy = {'changes': 'changes', 'errors': 'errors'}
+ def __init__(self, changes=None, errors=None):
+ '''
+ changes : typing.Sequence<+T_co>[~BundleChange]<~BundleChange>
+ errors : typing.Sequence<+T_co>[str]
+ '''
+ self.changes = [BundleChange.from_json(o) for o in changes or []]
+ self.errors = errors
+
+
class CharmActionSpec(Type):
_toSchema = {'description': 'description', 'params': 'params'}
_toPy = {'description': 'description', 'params': 'params'}
class CharmInfo(Type):
- _toSchema = {'config': 'config', 'actions': 'actions', 'revision': 'revision', 'metrics': 'metrics', 'url': 'url', 'meta': 'meta'}
- _toPy = {'config': 'config', 'actions': 'actions', 'revision': 'revision', 'metrics': 'metrics', 'url': 'url', 'meta': 'meta'}
+ _toSchema = {'actions': 'actions', 'config': 'config', 'meta': 'meta', 'metrics': 'metrics', 'revision': 'revision', 'url': 'url'}
+ _toPy = {'actions': 'actions', 'config': 'config', 'meta': 'meta', 'metrics': 'metrics', 'revision': 'revision', 'url': 'url'}
def __init__(self, actions=None, config=None, meta=None, metrics=None, revision=None, url=None):
'''
actions : CharmActions
class CharmMeta(Type):
- _toSchema = {'description': 'description', 'extra_bindings': 'extra-bindings', 'tags': 'tags', 'min_juju_version': 'min-juju-version', 'payload_classes': 'payload-classes', 'resources': 'resources', 'storage': 'storage', 'subordinate': 'subordinate', 'categories': 'categories', 'terms': 'terms', 'series': 'series', 'peers': 'peers', 'name': 'name', 'requires': 'requires', 'summary': 'summary', 'provides': 'provides'}
- _toPy = {'description': 'description', 'min-juju-version': 'min_juju_version', 'peers': 'peers', 'provides': 'provides', 'resources': 'resources', 'extra-bindings': 'extra_bindings', 'terms': 'terms', 'subordinate': 'subordinate', 'categories': 'categories', 'series': 'series', 'storage': 'storage', 'name': 'name', 'requires': 'requires', 'summary': 'summary', 'payload-classes': 'payload_classes', 'tags': 'tags'}
+ _toSchema = {'categories': 'categories', 'description': 'description', 'extra_bindings': 'extra-bindings', 'min_juju_version': 'min-juju-version', 'name': 'name', 'payload_classes': 'payload-classes', 'peers': 'peers', 'provides': 'provides', 'requires': 'requires', 'resources': 'resources', 'series': 'series', 'storage': 'storage', 'subordinate': 'subordinate', 'summary': 'summary', 'tags': 'tags', 'terms': 'terms'}
+ _toPy = {'categories': 'categories', 'description': 'description', 'extra-bindings': 'extra_bindings', 'min-juju-version': 'min_juju_version', 'name': 'name', 'payload-classes': 'payload_classes', 'peers': 'peers', 'provides': 'provides', 'requires': 'requires', 'resources': 'resources', 'series': 'series', 'storage': 'storage', 'subordinate': 'subordinate', 'summary': 'summary', 'tags': 'tags', 'terms': 'terms'}
def __init__(self, categories=None, description=None, extra_bindings=None, min_juju_version=None, name=None, payload_classes=None, peers=None, provides=None, requires=None, resources=None, series=None, storage=None, subordinate=None, summary=None, tags=None, terms=None):
'''
categories : typing.Sequence<+T_co>[str]
class CharmMetric(Type):
_toSchema = {'description': 'description', 'type_': 'type'}
- _toPy = {'type': 'type_', 'description': 'description'}
+ _toPy = {'description': 'description', 'type': 'type_'}
def __init__(self, description=None, type_=None):
'''
description : str
class CharmMetrics(Type):
- _toSchema = {'metrics': 'metrics'}
- _toPy = {'metrics': 'metrics'}
- def __init__(self, metrics=None):
+ _toSchema = {'metrics': 'metrics', 'plan': 'plan'}
+ _toPy = {'metrics': 'metrics', 'plan': 'plan'}
+ def __init__(self, metrics=None, plan=None):
'''
metrics : typing.Mapping<~KT, +VT_co>[str, ~CharmMetric]<~CharmMetric>
+ plan : CharmPlan
'''
self.metrics = metrics
+ self.plan = CharmPlan.from_json(plan) if plan else None
class CharmOption(Type):
- _toSchema = {'description': 'description', 'default': 'default', 'type_': 'type'}
- _toPy = {'type': 'type_', 'description': 'description', 'default': 'default'}
+ _toSchema = {'default': 'default', 'description': 'description', 'type_': 'type'}
+ _toPy = {'default': 'default', 'description': 'description', 'type': 'type_'}
def __init__(self, default=None, description=None, type_=None):
'''
default : typing.Mapping<~KT, +VT_co>[str, typing.Any]
class CharmPayloadClass(Type):
_toSchema = {'name': 'name', 'type_': 'type'}
- _toPy = {'type': 'type_', 'name': 'name'}
+ _toPy = {'name': 'name', 'type': 'type_'}
def __init__(self, name=None, type_=None):
'''
name : str
self.type_ = type_
+class CharmPlan(Type):
+ _toSchema = {'required': 'required'}
+ _toPy = {'required': 'required'}
+ def __init__(self, required=None):
+ '''
+ required : bool
+ '''
+ self.required = required
+
+
class CharmResourceMeta(Type):
- _toSchema = {'description': 'description', 'type_': 'type', 'path': 'path', 'name': 'name'}
- _toPy = {'type': 'type_', 'description': 'description', 'path': 'path', 'name': 'name'}
+ _toSchema = {'description': 'description', 'name': 'name', 'path': 'path', 'type_': 'type'}
+ _toPy = {'description': 'description', 'name': 'name', 'path': 'path', 'type': 'type_'}
def __init__(self, description=None, name=None, path=None, type_=None):
'''
description : str
class CharmStorage(Type):
- _toSchema = {'shared': 'shared', 'count_min': 'count-min', 'properties': 'properties', 'type_': 'type', 'description': 'description', 'name': 'name', 'location': 'location', 'minimum_size': 'minimum-size', 'read_only': 'read-only', 'count_max': 'count-max'}
- _toPy = {'description': 'description', 'count-min': 'count_min', 'minimum-size': 'minimum_size', 'shared': 'shared', 'name': 'name', 'location': 'location', 'type': 'type_', 'count-max': 'count_max', 'read-only': 'read_only', 'properties': 'properties'}
+ _toSchema = {'count_max': 'count-max', 'count_min': 'count-min', 'description': 'description', 'location': 'location', 'minimum_size': 'minimum-size', 'name': 'name', 'properties': 'properties', 'read_only': 'read-only', 'shared': 'shared', 'type_': 'type'}
+ _toPy = {'count-max': 'count_max', 'count-min': 'count_min', 'description': 'description', 'location': 'location', 'minimum-size': 'minimum_size', 'name': 'name', 'properties': 'properties', 'read-only': 'read_only', 'shared': 'shared', 'type': 'type_'}
def __init__(self, count_max=None, count_min=None, description=None, location=None, minimum_size=None, name=None, properties=None, read_only=None, shared=None, type_=None):
'''
count_max : int
class AddCharmWithAuthorization(Type):
- _toSchema = {'macaroon': 'macaroon', 'channel': 'channel', 'url': 'url'}
- _toPy = {'macaroon': 'macaroon', 'channel': 'channel', 'url': 'url'}
+ _toSchema = {'channel': 'channel', 'macaroon': 'macaroon', 'url': 'url'}
+ _toPy = {'channel': 'channel', 'macaroon': 'macaroon', 'url': 'url'}
def __init__(self, channel=None, macaroon=None, url=None):
'''
channel : str
class AddMachineParams(Type):
- _toSchema = {'addresses': 'addresses', 'disks': 'disks', 'hardware_characteristics': 'hardware-characteristics', 'nonce': 'nonce', 'constraints': 'constraints', 'series': 'series', 'placement': 'placement', 'parent_id': 'parent-id', 'jobs': 'jobs', 'instance_id': 'instance-id', 'container_type': 'container-type'}
- _toPy = {'addresses': 'addresses', 'disks': 'disks', 'instance-id': 'instance_id', 'container-type': 'container_type', 'nonce': 'nonce', 'constraints': 'constraints', 'series': 'series', 'placement': 'placement', 'parent-id': 'parent_id', 'hardware-characteristics': 'hardware_characteristics', 'jobs': 'jobs'}
+ _toSchema = {'addresses': 'addresses', 'constraints': 'constraints', 'container_type': 'container-type', 'disks': 'disks', 'hardware_characteristics': 'hardware-characteristics', 'instance_id': 'instance-id', 'jobs': 'jobs', 'nonce': 'nonce', 'parent_id': 'parent-id', 'placement': 'placement', 'series': 'series'}
+ _toPy = {'addresses': 'addresses', 'constraints': 'constraints', 'container-type': 'container_type', 'disks': 'disks', 'hardware-characteristics': 'hardware_characteristics', 'instance-id': 'instance_id', 'jobs': 'jobs', 'nonce': 'nonce', 'parent-id': 'parent_id', 'placement': 'placement', 'series': 'series'}
def __init__(self, addresses=None, constraints=None, container_type=None, disks=None, hardware_characteristics=None, instance_id=None, jobs=None, nonce=None, parent_id=None, placement=None, series=None):
'''
addresses : typing.Sequence<+T_co>[~Address]<~Address>
class AddMachinesResult(Type):
- _toSchema = {'machine': 'machine', 'error': 'error'}
- _toPy = {'machine': 'machine', 'error': 'error'}
+ _toSchema = {'error': 'error', 'machine': 'machine'}
+ _toPy = {'error': 'error', 'machine': 'machine'}
def __init__(self, error=None, machine=None):
'''
error : Error
class Address(Type):
- _toSchema = {'space_name': 'space-name', 'type_': 'type', 'scope': 'scope', 'value': 'value'}
- _toPy = {'type': 'type_', 'value': 'value', 'scope': 'scope', 'space-name': 'space_name'}
+ _toSchema = {'scope': 'scope', 'space_name': 'space-name', 'type_': 'type', 'value': 'value'}
+ _toPy = {'scope': 'scope', 'space-name': 'space_name', 'type': 'type_', 'value': 'value'}
def __init__(self, scope=None, space_name=None, type_=None, value=None):
'''
scope : str
class AgentVersionResult(Type):
- _toSchema = {'build': 'Build', 'patch': 'Patch', 'tag': 'Tag', 'minor': 'Minor', 'major': 'Major'}
- _toPy = {'Tag': 'tag', 'Major': 'major', 'Patch': 'patch', 'Minor': 'minor', 'Build': 'build'}
- def __init__(self, build=None, major=None, minor=None, patch=None, tag=None):
+ _toSchema = {'version': 'version'}
+ _toPy = {'version': 'version'}
+ def __init__(self, version=None):
'''
- build : int
- major : int
- minor : int
- patch : int
- tag : str
+ version : Number
'''
- self.build = build
- self.major = major
- self.minor = minor
- self.patch = patch
- self.tag = tag
+ self.version = Number.from_json(version) if version else None
class AllWatcherId(Type):
class ApplicationStatus(Type):
- _toSchema = {'can_upgrade_to': 'can-upgrade-to', 'subordinate_to': 'subordinate-to', 'workload_version': 'workload-version', 'life': 'life', 'charm': 'charm', 'status': 'status', 'units': 'units', 'meter_statuses': 'meter-statuses', 'series': 'series', 'err': 'err', 'relations': 'relations', 'exposed': 'exposed'}
- _toPy = {'can-upgrade-to': 'can_upgrade_to', 'workload-version': 'workload_version', 'life': 'life', 'charm': 'charm', 'status': 'status', 'units': 'units', 'series': 'series', 'err': 'err', 'relations': 'relations', 'meter-statuses': 'meter_statuses', 'exposed': 'exposed', 'subordinate-to': 'subordinate_to'}
+ _toSchema = {'can_upgrade_to': 'can-upgrade-to', 'charm': 'charm', 'err': 'err', 'exposed': 'exposed', 'life': 'life', 'meter_statuses': 'meter-statuses', 'relations': 'relations', 'series': 'series', 'status': 'status', 'subordinate_to': 'subordinate-to', 'units': 'units', 'workload_version': 'workload-version'}
+ _toPy = {'can-upgrade-to': 'can_upgrade_to', 'charm': 'charm', 'err': 'err', 'exposed': 'exposed', 'life': 'life', 'meter-statuses': 'meter_statuses', 'relations': 'relations', 'series': 'series', 'status': 'status', 'subordinate-to': 'subordinate_to', 'units': 'units', 'workload-version': 'workload_version'}
def __init__(self, can_upgrade_to=None, charm=None, err=None, exposed=None, life=None, meter_statuses=None, relations=None, series=None, status=None, subordinate_to=None, units=None, workload_version=None):
'''
can_upgrade_to : str
class Binary(Type):
- _toSchema = {'number': 'Number', 'series': 'Series', 'arch': 'Arch'}
- _toPy = {'Series': 'series', 'Arch': 'arch', 'Number': 'number'}
+ _toSchema = {'arch': 'Arch', 'number': 'Number', 'series': 'Series'}
+ _toPy = {'Arch': 'arch', 'Number': 'number', 'Series': 'series'}
def __init__(self, arch=None, number=None, series=None):
'''
arch : str
self.series = series
-class BundleChangesChange(Type):
- _toSchema = {'args': 'args', 'requires': 'requires', 'id_': 'id', 'method': 'method'}
- _toPy = {'args': 'args', 'id': 'id_', 'requires': 'requires', 'method': 'method'}
- def __init__(self, args=None, id_=None, method=None, requires=None):
- '''
- args : typing.Sequence<+T_co>[typing.Any]
- id_ : str
- method : str
- requires : typing.Sequence<+T_co>[str]
- '''
- self.args = args
- self.id_ = id_
- self.method = method
- self.requires = requires
-
-
class ConfigValue(Type):
_toSchema = {'source': 'source', 'value': 'value'}
_toPy = {'source': 'source', 'value': 'value'}
class DestroyMachines(Type):
- _toSchema = {'machine_names': 'machine-names', 'force': 'force'}
+ _toSchema = {'force': 'force', 'machine_names': 'machine-names'}
_toPy = {'force': 'force', 'machine-names': 'machine_names'}
def __init__(self, force=None, machine_names=None):
'''
class DetailedStatus(Type):
- _toSchema = {'info': 'info', 'data': 'data', 'kind': 'kind', 'since': 'since', 'err': 'err', 'life': 'life', 'status': 'status', 'version': 'version'}
- _toPy = {'info': 'info', 'data': 'data', 'kind': 'kind', 'since': 'since', 'err': 'err', 'life': 'life', 'status': 'status', 'version': 'version'}
+ _toSchema = {'data': 'data', 'err': 'err', 'info': 'info', 'kind': 'kind', 'life': 'life', 'since': 'since', 'status': 'status', 'version': 'version'}
+ _toPy = {'data': 'data', 'err': 'err', 'info': 'info', 'kind': 'kind', 'life': 'life', 'since': 'since', 'status': 'status', 'version': 'version'}
def __init__(self, data=None, err=None, info=None, kind=None, life=None, since=None, status=None, version=None):
'''
data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
class EntityStatus(Type):
- _toSchema = {'info': 'info', 'data': 'data', 'status': 'status', 'since': 'since'}
- _toPy = {'info': 'info', 'data': 'data', 'status': 'status', 'since': 'since'}
+ _toSchema = {'data': 'data', 'info': 'info', 'since': 'since', 'status': 'status'}
+ _toPy = {'data': 'data', 'info': 'info', 'since': 'since', 'status': 'status'}
def __init__(self, data=None, info=None, since=None, status=None):
'''
data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
class FindToolsParams(Type):
- _toSchema = {'series': 'series', 'number': 'number', 'minor': 'minor', 'major': 'major', 'arch': 'arch'}
- _toPy = {'series': 'series', 'number': 'number', 'minor': 'minor', 'major': 'major', 'arch': 'arch'}
+ _toSchema = {'arch': 'arch', 'major': 'major', 'minor': 'minor', 'number': 'number', 'series': 'series'}
+ _toPy = {'arch': 'arch', 'major': 'major', 'minor': 'minor', 'number': 'number', 'series': 'series'}
def __init__(self, arch=None, major=None, minor=None, number=None, series=None):
'''
arch : str
class FindToolsResult(Type):
- _toSchema = {'list_': 'list', 'error': 'error'}
- _toPy = {'list': 'list_', 'error': 'error'}
+ _toSchema = {'error': 'error', 'list_': 'list'}
+ _toPy = {'error': 'error', 'list': 'list_'}
def __init__(self, error=None, list_=None):
'''
error : Error
class FullStatus(Type):
- _toSchema = {'relations': 'relations', 'machines': 'machines', 'applications': 'applications', 'model': 'model'}
- _toPy = {'relations': 'relations', 'machines': 'machines', 'applications': 'applications', 'model': 'model'}
- def __init__(self, applications=None, machines=None, model=None, relations=None):
+ _toSchema = {'applications': 'applications', 'machines': 'machines', 'model': 'model', 'relations': 'relations', 'remote_applications': 'remote-applications'}
+ _toPy = {'applications': 'applications', 'machines': 'machines', 'model': 'model', 'relations': 'relations', 'remote-applications': 'remote_applications'}
+ def __init__(self, applications=None, machines=None, model=None, relations=None, remote_applications=None):
'''
applications : typing.Mapping<~KT, +VT_co>[str, ~ApplicationStatus]<~ApplicationStatus>
machines : typing.Mapping<~KT, +VT_co>[str, ~MachineStatus]<~MachineStatus>
model : ModelStatusInfo
relations : typing.Sequence<+T_co>[~RelationStatus]<~RelationStatus>
+ remote_applications : typing.Mapping<~KT, +VT_co>[str, ~RemoteApplicationStatus]<~RemoteApplicationStatus>
'''
self.applications = applications
self.machines = machines
self.model = ModelStatusInfo.from_json(model) if model else None
self.relations = [RelationStatus.from_json(o) for o in relations or []]
-
-
-class GetBundleChangesParams(Type):
- _toSchema = {'yaml': 'yaml'}
- _toPy = {'yaml': 'yaml'}
- def __init__(self, yaml=None):
- '''
- yaml : str
- '''
- self.yaml = yaml
-
-
-class GetBundleChangesResults(Type):
- _toSchema = {'errors': 'errors', 'changes': 'changes'}
- _toPy = {'errors': 'errors', 'changes': 'changes'}
- def __init__(self, changes=None, errors=None):
- '''
- changes : typing.Sequence<+T_co>[~BundleChangesChange]<~BundleChangesChange>
- errors : typing.Sequence<+T_co>[str]
- '''
- self.changes = [BundleChangesChange.from_json(o) for o in changes or []]
- self.errors = errors
+ self.remote_applications = remote_applications
class HardwareCharacteristics(Type):
- _toSchema = {'cpu_power': 'cpu-power', 'tags': 'tags', 'availability_zone': 'availability-zone', 'mem': 'mem', 'root_disk': 'root-disk', 'arch': 'arch', 'cpu_cores': 'cpu-cores'}
- _toPy = {'cpu-power': 'cpu_power', 'tags': 'tags', 'arch': 'arch', 'mem': 'mem', 'availability-zone': 'availability_zone', 'cpu-cores': 'cpu_cores', 'root-disk': 'root_disk'}
+ _toSchema = {'arch': 'arch', 'availability_zone': 'availability-zone', 'cpu_cores': 'cpu-cores', 'cpu_power': 'cpu-power', 'mem': 'mem', 'root_disk': 'root-disk', 'tags': 'tags'}
+ _toPy = {'arch': 'arch', 'availability-zone': 'availability_zone', 'cpu-cores': 'cpu_cores', 'cpu-power': 'cpu_power', 'mem': 'mem', 'root-disk': 'root_disk', 'tags': 'tags'}
def __init__(self, arch=None, availability_zone=None, cpu_cores=None, cpu_power=None, mem=None, root_disk=None, tags=None):
'''
arch : str
class History(Type):
- _toSchema = {'statuses': 'statuses', 'error': 'error'}
- _toPy = {'statuses': 'statuses', 'error': 'error'}
+ _toSchema = {'error': 'error', 'statuses': 'statuses'}
+ _toPy = {'error': 'error', 'statuses': 'statuses'}
def __init__(self, error=None, statuses=None):
'''
error : Error
class HostPort(Type):
- _toSchema = {'port': 'port', 'address': 'Address'}
+ _toSchema = {'address': 'Address', 'port': 'port'}
_toPy = {'Address': 'address', 'port': 'port'}
def __init__(self, address=None, port=None):
'''
self.port = port
+class MachineHardware(Type):
+ _toSchema = {'arch': 'arch', 'availability_zone': 'availability-zone', 'cores': 'cores', 'cpu_power': 'cpu-power', 'mem': 'mem', 'root_disk': 'root-disk', 'tags': 'tags'}
+ _toPy = {'arch': 'arch', 'availability-zone': 'availability_zone', 'cores': 'cores', 'cpu-power': 'cpu_power', 'mem': 'mem', 'root-disk': 'root_disk', 'tags': 'tags'}
+ def __init__(self, arch=None, availability_zone=None, cores=None, cpu_power=None, mem=None, root_disk=None, tags=None):
+ '''
+ arch : str
+ availability_zone : str
+ cores : int
+ cpu_power : int
+ mem : int
+ root_disk : int
+ tags : typing.Sequence<+T_co>[str]
+ '''
+ self.arch = arch
+ self.availability_zone = availability_zone
+ self.cores = cores
+ self.cpu_power = cpu_power
+ self.mem = mem
+ self.root_disk = root_disk
+ self.tags = tags
+
+
class MachineStatus(Type):
- _toSchema = {'dns_name': 'dns-name', 'jobs': 'jobs', 'id_': 'id', 'instance_id': 'instance-id', 'series': 'series', 'wants_vote': 'wants-vote', 'instance_status': 'instance-status', 'hardware': 'hardware', 'containers': 'containers', 'has_vote': 'has-vote', 'agent_status': 'agent-status'}
- _toPy = {'has-vote': 'has_vote', 'instance-id': 'instance_id', 'instance-status': 'instance_status', 'series': 'series', 'dns-name': 'dns_name', 'wants-vote': 'wants_vote', 'id': 'id_', 'agent-status': 'agent_status', 'containers': 'containers', 'jobs': 'jobs', 'hardware': 'hardware'}
- def __init__(self, agent_status=None, containers=None, dns_name=None, hardware=None, has_vote=None, id_=None, instance_id=None, instance_status=None, jobs=None, series=None, wants_vote=None):
+ _toSchema = {'agent_status': 'agent-status', 'containers': 'containers', 'dns_name': 'dns-name', 'hardware': 'hardware', 'has_vote': 'has-vote', 'id_': 'id', 'instance_id': 'instance-id', 'instance_status': 'instance-status', 'ip_addresses': 'ip-addresses', 'jobs': 'jobs', 'series': 'series', 'wants_vote': 'wants-vote'}
+ _toPy = {'agent-status': 'agent_status', 'containers': 'containers', 'dns-name': 'dns_name', 'hardware': 'hardware', 'has-vote': 'has_vote', 'id': 'id_', 'instance-id': 'instance_id', 'instance-status': 'instance_status', 'ip-addresses': 'ip_addresses', 'jobs': 'jobs', 'series': 'series', 'wants-vote': 'wants_vote'}
+ def __init__(self, agent_status=None, containers=None, dns_name=None, hardware=None, has_vote=None, id_=None, instance_id=None, instance_status=None, ip_addresses=None, jobs=None, series=None, wants_vote=None):
'''
agent_status : DetailedStatus
containers : typing.Mapping<~KT, +VT_co>[str, ~MachineStatus]<~MachineStatus>
id_ : str
instance_id : str
instance_status : DetailedStatus
+ ip_addresses : typing.Sequence<+T_co>[str]
jobs : typing.Sequence<+T_co>[str]
series : str
wants_vote : bool
self.id_ = id_
self.instance_id = instance_id
self.instance_status = DetailedStatus.from_json(instance_status) if instance_status else None
+ self.ip_addresses = ip_addresses
self.jobs = jobs
self.series = series
self.wants_vote = wants_vote
self.config = config
-class ModelDefaultValues(Type):
- _toSchema = {'config': 'config', 'cloud_tag': 'cloud-tag', 'cloud_region': 'cloud-region'}
- _toPy = {'config': 'config', 'cloud-tag': 'cloud_tag', 'cloud-region': 'cloud_region'}
- def __init__(self, cloud_region=None, cloud_tag=None, config=None):
- '''
- cloud_region : str
- cloud_tag : str
- config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
- '''
- self.cloud_region = cloud_region
- self.cloud_tag = cloud_tag
- self.config = config
-
-
-class ModelDefaults(Type):
- _toSchema = {'controller': 'controller', 'default': 'default', 'regions': 'regions'}
- _toPy = {'controller': 'controller', 'default': 'default', 'regions': 'regions'}
- def __init__(self, controller=None, default=None, regions=None):
- '''
- controller : typing.Mapping<~KT, +VT_co>[str, typing.Any]
- default : typing.Mapping<~KT, +VT_co>[str, typing.Any]
- regions : typing.Sequence<+T_co>[~RegionDefaults]<~RegionDefaults>
- '''
- self.controller = controller
- self.default = default
- self.regions = [RegionDefaults.from_json(o) for o in regions or []]
-
-
-class ModelDefaultsResult(Type):
- _toSchema = {'config': 'config'}
- _toPy = {'config': 'config'}
- def __init__(self, config=None):
- '''
- config : typing.Mapping<~KT, +VT_co>[str, ~ModelDefaults]<~ModelDefaults>
- '''
- self.config = config
-
-
class ModelInfo(Type):
- _toSchema = {'default_series': 'default-series', 'life': 'life', 'cloud_region': 'cloud-region', 'users': 'users', 'uuid': 'uuid', 'owner_tag': 'owner-tag', 'cloud': 'cloud', 'cloud_credential_tag': 'cloud-credential-tag', 'status': 'status', 'name': 'name', 'controller_uuid': 'controller-uuid', 'provider_type': 'provider-type'}
- _toPy = {'controller-uuid': 'controller_uuid', 'life': 'life', 'owner-tag': 'owner_tag', 'provider-type': 'provider_type', 'users': 'users', 'uuid': 'uuid', 'default-series': 'default_series', 'cloud': 'cloud', 'cloud-credential-tag': 'cloud_credential_tag', 'status': 'status', 'name': 'name', 'cloud-region': 'cloud_region'}
- def __init__(self, cloud=None, cloud_credential_tag=None, cloud_region=None, controller_uuid=None, default_series=None, life=None, name=None, owner_tag=None, provider_type=None, status=None, users=None, uuid=None):
+ _toSchema = {'cloud_credential_tag': 'cloud-credential-tag', 'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'controller_uuid': 'controller-uuid', 'default_series': 'default-series', 'life': 'life', 'machines': 'machines', 'name': 'name', 'owner_tag': 'owner-tag', 'provider_type': 'provider-type', 'status': 'status', 'users': 'users', 'uuid': 'uuid'}
+ _toPy = {'cloud-credential-tag': 'cloud_credential_tag', 'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'controller-uuid': 'controller_uuid', 'default-series': 'default_series', 'life': 'life', 'machines': 'machines', 'name': 'name', 'owner-tag': 'owner_tag', 'provider-type': 'provider_type', 'status': 'status', 'users': 'users', 'uuid': 'uuid'}
+ def __init__(self, cloud_credential_tag=None, cloud_region=None, cloud_tag=None, controller_uuid=None, default_series=None, life=None, machines=None, name=None, owner_tag=None, provider_type=None, status=None, users=None, uuid=None):
'''
- cloud : str
cloud_credential_tag : str
cloud_region : str
+ cloud_tag : str
controller_uuid : str
default_series : str
life : str
+ machines : typing.Sequence<+T_co>[~ModelMachineInfo]<~ModelMachineInfo>
name : str
owner_tag : str
provider_type : str
users : typing.Sequence<+T_co>[~ModelUserInfo]<~ModelUserInfo>
uuid : str
'''
- self.cloud = cloud
self.cloud_credential_tag = cloud_credential_tag
self.cloud_region = cloud_region
+ self.cloud_tag = cloud_tag
self.controller_uuid = controller_uuid
self.default_series = default_series
self.life = life
+ self.machines = [ModelMachineInfo.from_json(o) for o in machines or []]
self.name = name
self.owner_tag = owner_tag
self.provider_type = provider_type
self.uuid = uuid
+class ModelMachineInfo(Type):
+ _toSchema = {'hardware': 'hardware', 'has_vote': 'has-vote', 'id_': 'id', 'instance_id': 'instance-id', 'status': 'status', 'wants_vote': 'wants-vote'}
+ _toPy = {'hardware': 'hardware', 'has-vote': 'has_vote', 'id': 'id_', 'instance-id': 'instance_id', 'status': 'status', 'wants-vote': 'wants_vote'}
+ def __init__(self, hardware=None, has_vote=None, id_=None, instance_id=None, status=None, wants_vote=None):
+ '''
+ hardware : MachineHardware
+ has_vote : bool
+ id_ : str
+ instance_id : str
+ status : str
+ wants_vote : bool
+ '''
+ self.hardware = MachineHardware.from_json(hardware) if hardware else None
+ self.has_vote = has_vote
+ self.id_ = id_
+ self.instance_id = instance_id
+ self.status = status
+ self.wants_vote = wants_vote
+
+
class ModelSet(Type):
_toSchema = {'config': 'config'}
_toPy = {'config': 'config'}
class ModelStatusInfo(Type):
- _toSchema = {'cloud': 'cloud', 'name': 'name', 'migration': 'migration', 'region': 'region', 'available_version': 'available-version', 'version': 'version'}
- _toPy = {'available-version': 'available_version', 'cloud': 'cloud', 'name': 'name', 'migration': 'migration', 'region': 'region', 'version': 'version'}
- def __init__(self, available_version=None, cloud=None, migration=None, name=None, region=None, version=None):
+ _toSchema = {'available_version': 'available-version', 'cloud_tag': 'cloud-tag', 'migration': 'migration', 'name': 'name', 'region': 'region', 'version': 'version'}
+ _toPy = {'available-version': 'available_version', 'cloud-tag': 'cloud_tag', 'migration': 'migration', 'name': 'name', 'region': 'region', 'version': 'version'}
+ def __init__(self, available_version=None, cloud_tag=None, migration=None, name=None, region=None, version=None):
'''
available_version : str
- cloud : str
+ cloud_tag : str
migration : str
name : str
region : str
version : str
'''
self.available_version = available_version
- self.cloud = cloud
+ self.cloud_tag = cloud_tag
self.migration = migration
self.name = name
self.region = region
self.keys = keys
-class ModelUnsetKeys(Type):
- _toSchema = {'cloud_tag': 'cloud-tag', 'keys': 'keys', 'cloud_region': 'cloud-region'}
- _toPy = {'cloud-tag': 'cloud_tag', 'cloud-region': 'cloud_region', 'keys': 'keys'}
- def __init__(self, cloud_region=None, cloud_tag=None, keys=None):
- '''
- cloud_region : str
- cloud_tag : str
- keys : typing.Sequence<+T_co>[str]
- '''
- self.cloud_region = cloud_region
- self.cloud_tag = cloud_tag
- self.keys = keys
-
-
class ModelUserInfo(Type):
- _toSchema = {'display_name': 'display-name', 'access': 'access', 'user': 'user', 'last_connection': 'last-connection'}
- _toPy = {'last-connection': 'last_connection', 'access': 'access', 'user': 'user', 'display-name': 'display_name'}
+ _toSchema = {'access': 'access', 'display_name': 'display-name', 'last_connection': 'last-connection', 'user': 'user'}
+ _toPy = {'access': 'access', 'display-name': 'display_name', 'last-connection': 'last_connection', 'user': 'user'}
def __init__(self, access=None, display_name=None, last_connection=None, user=None):
'''
access : str
class ModelUserInfoResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class ProvisioningScriptParams(Type):
- _toSchema = {'data_dir': 'data-dir', 'nonce': 'nonce', 'disable_package_commands': 'disable-package-commands', 'machine_id': 'machine-id'}
- _toPy = {'machine-id': 'machine_id', 'data-dir': 'data_dir', 'nonce': 'nonce', 'disable-package-commands': 'disable_package_commands'}
+ _toSchema = {'data_dir': 'data-dir', 'disable_package_commands': 'disable-package-commands', 'machine_id': 'machine-id', 'nonce': 'nonce'}
+ _toPy = {'data-dir': 'data_dir', 'disable-package-commands': 'disable_package_commands', 'machine-id': 'machine_id', 'nonce': 'nonce'}
def __init__(self, data_dir=None, disable_package_commands=None, machine_id=None, nonce=None):
'''
data_dir : str
self.public_address = public_address
-class RegionDefaults(Type):
- _toSchema = {'value': 'value', 'region_name': 'region-name'}
- _toPy = {'region-name': 'region_name', 'value': 'value'}
- def __init__(self, region_name=None, value=None):
- '''
- region_name : str
- value : typing.Mapping<~KT, +VT_co>[str, typing.Any]
- '''
- self.region_name = region_name
- self.value = value
-
-
class RelationStatus(Type):
- _toSchema = {'interface': 'interface', 'endpoints': 'endpoints', 'id_': 'id', 'key': 'key', 'scope': 'scope'}
- _toPy = {'id': 'id_', 'interface': 'interface', 'endpoints': 'endpoints', 'scope': 'scope', 'key': 'key'}
+ _toSchema = {'endpoints': 'endpoints', 'id_': 'id', 'interface': 'interface', 'key': 'key', 'scope': 'scope'}
+ _toPy = {'endpoints': 'endpoints', 'id': 'id_', 'interface': 'interface', 'key': 'key', 'scope': 'scope'}
def __init__(self, endpoints=None, id_=None, interface=None, key=None, scope=None):
'''
endpoints : typing.Sequence<+T_co>[~EndpointStatus]<~EndpointStatus>
self.scope = scope
+class RemoteApplicationStatus(Type):
+ _toSchema = {'application_name': 'application-name', 'application_url': 'application-url', 'endpoints': 'endpoints', 'err': 'err', 'life': 'life', 'relations': 'relations', 'status': 'status'}
+ _toPy = {'application-name': 'application_name', 'application-url': 'application_url', 'endpoints': 'endpoints', 'err': 'err', 'life': 'life', 'relations': 'relations', 'status': 'status'}
+ def __init__(self, application_name=None, application_url=None, endpoints=None, err=None, life=None, relations=None, status=None):
+ '''
+ application_name : str
+ application_url : str
+ endpoints : typing.Sequence<+T_co>[~RemoteEndpoint]<~RemoteEndpoint>
+ err : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ life : str
+ relations : typing.Sequence<+T_co>[str]
+ status : DetailedStatus
+ '''
+ self.application_name = application_name
+ self.application_url = application_url
+ self.endpoints = [RemoteEndpoint.from_json(o) for o in endpoints or []]
+ self.err = err
+ self.life = life
+ self.relations = relations
+ self.status = DetailedStatus.from_json(status) if status else None
+
+
+class RemoteEndpoint(Type):
+ _toSchema = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'role': 'role', 'scope': 'scope'}
+ _toPy = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'role': 'role', 'scope': 'scope'}
+ def __init__(self, interface=None, limit=None, name=None, role=None, scope=None):
+ '''
+ interface : str
+ limit : int
+ name : str
+ role : str
+ scope : str
+ '''
+ self.interface = interface
+ self.limit = limit
+ self.name = name
+ self.role = role
+ self.scope = scope
+
+
class ResolveCharmResult(Type):
- _toSchema = {'url': 'url', 'error': 'error'}
- _toPy = {'url': 'url', 'error': 'error'}
+ _toSchema = {'error': 'error', 'url': 'url'}
+ _toPy = {'error': 'error', 'url': 'url'}
def __init__(self, error=None, url=None):
'''
error : str
class Resolved(Type):
- _toSchema = {'unit_name': 'unit-name', 'retry': 'retry'}
- _toPy = {'unit-name': 'unit_name', 'retry': 'retry'}
+ _toSchema = {'retry': 'retry', 'unit_name': 'unit-name'}
+ _toPy = {'retry': 'retry', 'unit-name': 'unit_name'}
def __init__(self, retry=None, unit_name=None):
'''
retry : bool
class SetModelAgentVersion(Type):
- _toSchema = {'build': 'Build', 'patch': 'Patch', 'tag': 'Tag', 'minor': 'Minor', 'major': 'Major'}
- _toPy = {'Tag': 'tag', 'Major': 'major', 'Patch': 'patch', 'Minor': 'minor', 'Build': 'build'}
- def __init__(self, build=None, major=None, minor=None, patch=None, tag=None):
- '''
- build : int
- major : int
- minor : int
- patch : int
- tag : str
- '''
- self.build = build
- self.major = major
- self.minor = minor
- self.patch = patch
- self.tag = tag
-
-
-class SetModelDefaults(Type):
- _toSchema = {'config': 'config'}
- _toPy = {'config': 'config'}
- def __init__(self, config=None):
+ _toSchema = {'version': 'version'}
+ _toPy = {'version': 'version'}
+ def __init__(self, version=None):
'''
- config : typing.Sequence<+T_co>[~ModelDefaultValues]<~ModelDefaultValues>
+ version : Number
'''
- self.config = [ModelDefaultValues.from_json(o) for o in config or []]
+ self.version = Number.from_json(version) if version else None
class StatusHistoryFilter(Type):
- _toSchema = {'size': 'size', 'date': 'date', 'delta': 'delta'}
- _toPy = {'size': 'size', 'date': 'date', 'delta': 'delta'}
+ _toSchema = {'date': 'date', 'delta': 'delta', 'size': 'size'}
+ _toPy = {'date': 'date', 'delta': 'delta', 'size': 'size'}
def __init__(self, date=None, delta=None, size=None):
'''
date : str
class StatusHistoryRequest(Type):
- _toSchema = {'historykind': 'historyKind', 'tag': 'tag', 'size': 'size', 'filter_': 'filter'}
- _toPy = {'filter': 'filter_', 'historyKind': 'historykind', 'tag': 'tag', 'size': 'size'}
+ _toSchema = {'filter_': 'filter', 'historykind': 'historyKind', 'size': 'size', 'tag': 'tag'}
+ _toPy = {'filter': 'filter_', 'historyKind': 'historykind', 'size': 'size', 'tag': 'tag'}
def __init__(self, filter_=None, historykind=None, size=None, tag=None):
'''
filter_ : StatusHistoryFilter
class StatusHistoryResult(Type):
- _toSchema = {'history': 'history', 'error': 'error'}
- _toPy = {'history': 'history', 'error': 'error'}
+ _toSchema = {'error': 'error', 'history': 'history'}
+ _toPy = {'error': 'error', 'history': 'history'}
def __init__(self, error=None, history=None):
'''
error : Error
class Tools(Type):
- _toSchema = {'version': 'version', 'sha256': 'sha256', 'size': 'size', 'url': 'url'}
- _toPy = {'version': 'version', 'sha256': 'sha256', 'size': 'size', 'url': 'url'}
+ _toSchema = {'sha256': 'sha256', 'size': 'size', 'url': 'url', 'version': 'version'}
+ _toPy = {'sha256': 'sha256', 'size': 'size', 'url': 'url', 'version': 'version'}
def __init__(self, sha256=None, size=None, url=None, version=None):
'''
sha256 : str
class UnitStatus(Type):
- _toSchema = {'workload_status': 'workload-status', 'opened_ports': 'opened-ports', 'subordinates': 'subordinates', 'workload_version': 'workload-version', 'public_address': 'public-address', 'charm': 'charm', 'agent_status': 'agent-status', 'machine': 'machine'}
- _toPy = {'public-address': 'public_address', 'workload-version': 'workload_version', 'subordinates': 'subordinates', 'opened-ports': 'opened_ports', 'charm': 'charm', 'workload-status': 'workload_status', 'machine': 'machine', 'agent-status': 'agent_status'}
- def __init__(self, agent_status=None, charm=None, machine=None, opened_ports=None, public_address=None, subordinates=None, workload_status=None, workload_version=None):
+ _toSchema = {'agent_status': 'agent-status', 'charm': 'charm', 'leader': 'leader', 'machine': 'machine', 'opened_ports': 'opened-ports', 'public_address': 'public-address', 'subordinates': 'subordinates', 'workload_status': 'workload-status', 'workload_version': 'workload-version'}
+ _toPy = {'agent-status': 'agent_status', 'charm': 'charm', 'leader': 'leader', 'machine': 'machine', 'opened-ports': 'opened_ports', 'public-address': 'public_address', 'subordinates': 'subordinates', 'workload-status': 'workload_status', 'workload-version': 'workload_version'}
+ def __init__(self, agent_status=None, charm=None, leader=None, machine=None, opened_ports=None, public_address=None, subordinates=None, workload_status=None, workload_version=None):
'''
agent_status : DetailedStatus
charm : str
+ leader : bool
machine : str
opened_ports : typing.Sequence<+T_co>[str]
public_address : str
'''
self.agent_status = DetailedStatus.from_json(agent_status) if agent_status else None
self.charm = charm
+ self.leader = leader
self.machine = machine
self.opened_ports = opened_ports
self.public_address = public_address
self.workload_version = workload_version
-class UnsetModelDefaults(Type):
- _toSchema = {'keys': 'keys'}
- _toPy = {'keys': 'keys'}
- def __init__(self, keys=None):
- '''
- keys : typing.Sequence<+T_co>[~ModelUnsetKeys]<~ModelUnsetKeys>
- '''
- self.keys = [ModelUnsetKeys.from_json(o) for o in keys or []]
-
-
class Cloud(Type):
- _toSchema = {'type_': 'type', 'identity_endpoint': 'identity-endpoint', 'storage_endpoint': 'storage-endpoint', 'regions': 'regions', 'auth_types': 'auth-types', 'endpoint': 'endpoint'}
- _toPy = {'auth-types': 'auth_types', 'regions': 'regions', 'type': 'type_', 'identity-endpoint': 'identity_endpoint', 'endpoint': 'endpoint', 'storage-endpoint': 'storage_endpoint'}
+ _toSchema = {'auth_types': 'auth-types', 'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'regions': 'regions', 'storage_endpoint': 'storage-endpoint', 'type_': 'type'}
+ _toPy = {'auth-types': 'auth_types', 'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'regions': 'regions', 'storage-endpoint': 'storage_endpoint', 'type': 'type_'}
def __init__(self, auth_types=None, endpoint=None, identity_endpoint=None, regions=None, storage_endpoint=None, type_=None):
'''
auth_types : typing.Sequence<+T_co>[str]
class CloudCredentialResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class CloudRegion(Type):
- _toSchema = {'name': 'name', 'endpoint': 'endpoint', 'storage_endpoint': 'storage-endpoint', 'identity_endpoint': 'identity-endpoint'}
- _toPy = {'identity-endpoint': 'identity_endpoint', 'endpoint': 'endpoint', 'storage-endpoint': 'storage_endpoint', 'name': 'name'}
+ _toSchema = {'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'name': 'name', 'storage_endpoint': 'storage-endpoint'}
+ _toPy = {'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'name': 'name', 'storage-endpoint': 'storage_endpoint'}
def __init__(self, endpoint=None, identity_endpoint=None, name=None, storage_endpoint=None):
'''
endpoint : str
class StringsResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class UpdateCloudCredential(Type):
- _toSchema = {'tag': 'tag', 'credential': 'credential'}
- _toPy = {'tag': 'tag', 'credential': 'credential'}
+ _toSchema = {'credential': 'credential', 'tag': 'tag'}
+ _toPy = {'credential': 'credential', 'tag': 'tag'}
def __init__(self, credential=None, tag=None):
'''
credential : CloudCredential
self.destroy_models = destroy_models
+class HostedModelConfig(Type):
+ _toSchema = {'cloud_spec': 'cloud-spec', 'config': 'config', 'error': 'error', 'name': 'name', 'owner': 'owner'}
+ _toPy = {'cloud-spec': 'cloud_spec', 'config': 'config', 'error': 'error', 'name': 'name', 'owner': 'owner'}
+ def __init__(self, cloud_spec=None, config=None, error=None, name=None, owner=None):
+ '''
+ cloud_spec : CloudSpec
+ config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ error : Error
+ name : str
+ owner : str
+ '''
+ self.cloud_spec = CloudSpec.from_json(cloud_spec) if cloud_spec else None
+ self.config = config
+ self.error = Error.from_json(error) if error else None
+ self.name = name
+ self.owner = owner
+
+
+class HostedModelConfigsResults(Type):
+ _toSchema = {'models': 'models'}
+ _toPy = {'models': 'models'}
+ def __init__(self, models=None):
+ '''
+ models : typing.Sequence<+T_co>[~HostedModelConfig]<~HostedModelConfig>
+ '''
+ self.models = [HostedModelConfig.from_json(o) for o in models or []]
+
+
class InitiateMigrationArgs(Type):
_toSchema = {'specs': 'specs'}
_toPy = {'specs': 'specs'}
class InitiateMigrationResult(Type):
- _toSchema = {'model_tag': 'model-tag', 'migration_id': 'migration-id', 'error': 'error'}
- _toPy = {'model-tag': 'model_tag', 'migration-id': 'migration_id', 'error': 'error'}
+ _toSchema = {'error': 'error', 'migration_id': 'migration-id', 'model_tag': 'model-tag'}
+ _toPy = {'error': 'error', 'migration-id': 'migration_id', 'model-tag': 'model_tag'}
def __init__(self, error=None, migration_id=None, model_tag=None):
'''
error : Error
class MigrationSpec(Type):
- _toSchema = {'model_tag': 'model-tag', 'target_info': 'target-info'}
- _toPy = {'model-tag': 'model_tag', 'target-info': 'target_info'}
- def __init__(self, model_tag=None, target_info=None):
+ _toSchema = {'external_control': 'external-control', 'model_tag': 'model-tag', 'skip_initial_prechecks': 'skip-initial-prechecks', 'target_info': 'target-info'}
+ _toPy = {'external-control': 'external_control', 'model-tag': 'model_tag', 'skip-initial-prechecks': 'skip_initial_prechecks', 'target-info': 'target_info'}
+ def __init__(self, external_control=None, model_tag=None, skip_initial_prechecks=None, target_info=None):
'''
+ external_control : bool
model_tag : str
+ skip_initial_prechecks : bool
target_info : MigrationTargetInfo
'''
+ self.external_control = external_control
self.model_tag = model_tag
+ self.skip_initial_prechecks = skip_initial_prechecks
self.target_info = MigrationTargetInfo.from_json(target_info) if target_info else None
class MigrationTargetInfo(Type):
- _toSchema = {'password': 'password', 'controller_tag': 'controller-tag', 'addrs': 'addrs', 'ca_cert': 'ca-cert', 'macaroon': 'macaroon', 'auth_tag': 'auth-tag'}
- _toPy = {'auth-tag': 'auth_tag', 'password': 'password', 'ca-cert': 'ca_cert', 'addrs': 'addrs', 'macaroon': 'macaroon', 'controller-tag': 'controller_tag'}
- def __init__(self, addrs=None, auth_tag=None, ca_cert=None, controller_tag=None, macaroon=None, password=None):
+ _toSchema = {'addrs': 'addrs', 'auth_tag': 'auth-tag', 'ca_cert': 'ca-cert', 'controller_tag': 'controller-tag', 'macaroons': 'macaroons', 'password': 'password'}
+ _toPy = {'addrs': 'addrs', 'auth-tag': 'auth_tag', 'ca-cert': 'ca_cert', 'controller-tag': 'controller_tag', 'macaroons': 'macaroons', 'password': 'password'}
+ def __init__(self, addrs=None, auth_tag=None, ca_cert=None, controller_tag=None, macaroons=None, password=None):
'''
addrs : typing.Sequence<+T_co>[str]
auth_tag : str
ca_cert : str
controller_tag : str
- macaroon : str
+ macaroons : str
password : str
'''
self.addrs = addrs
self.auth_tag = auth_tag
self.ca_cert = ca_cert
self.controller_tag = controller_tag
- self.macaroon = macaroon
+ self.macaroons = macaroons
self.password = password
class Model(Type):
- _toSchema = {'name': 'name', 'uuid': 'uuid', 'owner_tag': 'owner-tag'}
+ _toSchema = {'name': 'name', 'owner_tag': 'owner-tag', 'uuid': 'uuid'}
_toPy = {'name': 'name', 'owner-tag': 'owner_tag', 'uuid': 'uuid'}
def __init__(self, name=None, owner_tag=None, uuid=None):
'''
class ModelBlockInfo(Type):
- _toSchema = {'name': 'name', 'model_uuid': 'model-uuid', 'owner_tag': 'owner-tag', 'blocks': 'blocks'}
- _toPy = {'name': 'name', 'owner-tag': 'owner_tag', 'model-uuid': 'model_uuid', 'blocks': 'blocks'}
+ _toSchema = {'blocks': 'blocks', 'model_uuid': 'model-uuid', 'name': 'name', 'owner_tag': 'owner-tag'}
+ _toPy = {'blocks': 'blocks', 'model-uuid': 'model_uuid', 'name': 'name', 'owner-tag': 'owner_tag'}
def __init__(self, blocks=None, model_uuid=None, name=None, owner_tag=None):
'''
blocks : typing.Sequence<+T_co>[str]
class ModelStatus(Type):
- _toSchema = {'life': 'life', 'application_count': 'application-count', 'owner_tag': 'owner-tag', 'model_tag': 'model-tag', 'hosted_machine_count': 'hosted-machine-count'}
- _toPy = {'life': 'life', 'model-tag': 'model_tag', 'owner-tag': 'owner_tag', 'hosted-machine-count': 'hosted_machine_count', 'application-count': 'application_count'}
- def __init__(self, application_count=None, hosted_machine_count=None, life=None, model_tag=None, owner_tag=None):
+ _toSchema = {'application_count': 'application-count', 'hosted_machine_count': 'hosted-machine-count', 'life': 'life', 'machines': 'machines', 'model_tag': 'model-tag', 'owner_tag': 'owner-tag'}
+ _toPy = {'application-count': 'application_count', 'hosted-machine-count': 'hosted_machine_count', 'life': 'life', 'machines': 'machines', 'model-tag': 'model_tag', 'owner-tag': 'owner_tag'}
+ def __init__(self, application_count=None, hosted_machine_count=None, life=None, machines=None, model_tag=None, owner_tag=None):
'''
application_count : int
hosted_machine_count : int
life : str
+ machines : typing.Sequence<+T_co>[~ModelMachineInfo]<~ModelMachineInfo>
model_tag : str
owner_tag : str
'''
self.application_count = application_count
self.hosted_machine_count = hosted_machine_count
self.life = life
+ self.machines = [ModelMachineInfo.from_json(o) for o in machines or []]
self.model_tag = model_tag
self.owner_tag = owner_tag
class UserAccessResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class DeployerConnectionValues(Type):
_toSchema = {'api_addresses': 'api-addresses', 'state_addresses': 'state-addresses'}
- _toPy = {'state-addresses': 'state_addresses', 'api-addresses': 'api_addresses'}
+ _toPy = {'api-addresses': 'api_addresses', 'state-addresses': 'state_addresses'}
def __init__(self, api_addresses=None, state_addresses=None):
'''
api_addresses : typing.Sequence<+T_co>[str]
self.state_addresses = state_addresses
+class EntityStatusArgs(Type):
+ _toSchema = {'data': 'data', 'info': 'info', 'status': 'status', 'tag': 'tag'}
+ _toPy = {'data': 'data', 'info': 'info', 'status': 'status', 'tag': 'tag'}
+ def __init__(self, data=None, info=None, status=None, tag=None):
+ '''
+ data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ info : str
+ status : str
+ tag : str
+ '''
+ self.data = data
+ self.info = info
+ self.status = status
+ self.tag = tag
+
+
class LifeResult(Type):
- _toSchema = {'life': 'life', 'error': 'error'}
- _toPy = {'life': 'life', 'error': 'error'}
+ _toSchema = {'error': 'error', 'life': 'life'}
+ _toPy = {'error': 'error', 'life': 'life'}
def __init__(self, error=None, life=None):
'''
error : Error
self.results = [LifeResult.from_json(o) for o in results or []]
+class SetStatus(Type):
+ _toSchema = {'entities': 'entities'}
+ _toPy = {'entities': 'entities'}
+ def __init__(self, entities=None):
+ '''
+ entities : typing.Sequence<+T_co>[~EntityStatusArgs]<~EntityStatusArgs>
+ '''
+ self.entities = [EntityStatusArgs.from_json(o) for o in entities or []]
+
+
class StringsWatchResults(Type):
_toSchema = {'results': 'results'}
_toPy = {'results': 'results'}
class AddSubnetParams(Type):
- _toSchema = {'subnet_tag': 'subnet-tag', 'subnet_provider_id': 'subnet-provider-id', 'space_tag': 'space-tag', 'zones': 'zones'}
- _toPy = {'subnet-tag': 'subnet_tag', 'subnet-provider-id': 'subnet_provider_id', 'zones': 'zones', 'space-tag': 'space_tag'}
+ _toSchema = {'space_tag': 'space-tag', 'subnet_provider_id': 'subnet-provider-id', 'subnet_tag': 'subnet-tag', 'zones': 'zones'}
+ _toPy = {'space-tag': 'space_tag', 'subnet-provider-id': 'subnet_provider_id', 'subnet-tag': 'subnet_tag', 'zones': 'zones'}
def __init__(self, space_tag=None, subnet_provider_id=None, subnet_tag=None, zones=None):
'''
space_tag : str
class CreateSpaceParams(Type):
- _toSchema = {'provider_id': 'provider-id', 'space_tag': 'space-tag', 'subnet_tags': 'subnet-tags', 'public': 'public'}
- _toPy = {'subnet-tags': 'subnet_tags', 'space-tag': 'space_tag', 'public': 'public', 'provider-id': 'provider_id'}
+ _toSchema = {'provider_id': 'provider-id', 'public': 'public', 'space_tag': 'space-tag', 'subnet_tags': 'subnet-tags'}
+ _toPy = {'provider-id': 'provider_id', 'public': 'public', 'space-tag': 'space_tag', 'subnet-tags': 'subnet_tags'}
def __init__(self, provider_id=None, public=None, space_tag=None, subnet_tags=None):
'''
provider_id : str
class ProviderSpace(Type):
- _toSchema = {'name': 'name', 'provider_id': 'provider-id', 'subnets': 'subnets', 'error': 'error'}
- _toPy = {'name': 'name', 'subnets': 'subnets', 'provider-id': 'provider_id', 'error': 'error'}
+ _toSchema = {'error': 'error', 'name': 'name', 'provider_id': 'provider-id', 'subnets': 'subnets'}
+ _toPy = {'error': 'error', 'name': 'name', 'provider-id': 'provider_id', 'subnets': 'subnets'}
def __init__(self, error=None, name=None, provider_id=None, subnets=None):
'''
error : Error
class Subnet(Type):
- _toSchema = {'status': 'status', 'provider_id': 'provider-id', 'space_tag': 'space-tag', 'vlan_tag': 'vlan-tag', 'zones': 'zones', 'life': 'life', 'cidr': 'cidr'}
- _toPy = {'status': 'status', 'zones': 'zones', 'vlan-tag': 'vlan_tag', 'life': 'life', 'cidr': 'cidr', 'space-tag': 'space_tag', 'provider-id': 'provider_id'}
+ _toSchema = {'cidr': 'cidr', 'life': 'life', 'provider_id': 'provider-id', 'space_tag': 'space-tag', 'status': 'status', 'vlan_tag': 'vlan-tag', 'zones': 'zones'}
+ _toPy = {'cidr': 'cidr', 'life': 'life', 'provider-id': 'provider_id', 'space-tag': 'space_tag', 'status': 'status', 'vlan-tag': 'vlan_tag', 'zones': 'zones'}
def __init__(self, cidr=None, life=None, provider_id=None, space_tag=None, status=None, vlan_tag=None, zones=None):
'''
cidr : str
class BlockDevice(Type):
- _toSchema = {'uuid': 'UUID', 'busaddress': 'BusAddress', 'size': 'Size', 'hardwareid': 'HardwareId', 'filesystemtype': 'FilesystemType', 'label': 'Label', 'devicelinks': 'DeviceLinks', 'inuse': 'InUse', 'mountpoint': 'MountPoint', 'devicename': 'DeviceName'}
- _toPy = {'InUse': 'inuse', 'Size': 'size', 'Label': 'label', 'DeviceName': 'devicename', 'BusAddress': 'busaddress', 'FilesystemType': 'filesystemtype', 'MountPoint': 'mountpoint', 'UUID': 'uuid', 'HardwareId': 'hardwareid', 'DeviceLinks': 'devicelinks'}
+ _toSchema = {'busaddress': 'BusAddress', 'devicelinks': 'DeviceLinks', 'devicename': 'DeviceName', 'filesystemtype': 'FilesystemType', 'hardwareid': 'HardwareId', 'inuse': 'InUse', 'label': 'Label', 'mountpoint': 'MountPoint', 'size': 'Size', 'uuid': 'UUID'}
+ _toPy = {'BusAddress': 'busaddress', 'DeviceLinks': 'devicelinks', 'DeviceName': 'devicename', 'FilesystemType': 'filesystemtype', 'HardwareId': 'hardwareid', 'InUse': 'inuse', 'Label': 'label', 'MountPoint': 'mountpoint', 'Size': 'size', 'UUID': 'uuid'}
def __init__(self, busaddress=None, devicelinks=None, devicename=None, filesystemtype=None, hardwareid=None, inuse=None, label=None, mountpoint=None, size=None, uuid=None):
'''
busaddress : str
class EntitiesWatchResult(Type):
- _toSchema = {'changes': 'changes', 'watcher_id': 'watcher-id', 'error': 'error'}
- _toPy = {'watcher-id': 'watcher_id', 'changes': 'changes', 'error': 'error'}
+ _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
+ _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
def __init__(self, changes=None, error=None, watcher_id=None):
'''
changes : typing.Sequence<+T_co>[str]
class MachineStorageId(Type):
- _toSchema = {'machine_tag': 'machine-tag', 'attachment_tag': 'attachment-tag'}
+ _toSchema = {'attachment_tag': 'attachment-tag', 'machine_tag': 'machine-tag'}
_toPy = {'attachment-tag': 'attachment_tag', 'machine-tag': 'machine_tag'}
def __init__(self, attachment_tag=None, machine_tag=None):
'''
class MachineStorageIdsWatchResult(Type):
- _toSchema = {'changes': 'changes', 'watcher_id': 'watcher-id', 'error': 'error'}
- _toPy = {'watcher-id': 'watcher_id', 'changes': 'changes', 'error': 'error'}
+ _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
+ _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
def __init__(self, changes=None, error=None, watcher_id=None):
'''
changes : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
class BoolResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class MachinePortRange(Type):
- _toSchema = {'relation_tag': 'relation-tag', 'port_range': 'port-range', 'unit_tag': 'unit-tag'}
- _toPy = {'relation-tag': 'relation_tag', 'port-range': 'port_range', 'unit-tag': 'unit_tag'}
+ _toSchema = {'port_range': 'port-range', 'relation_tag': 'relation-tag', 'unit_tag': 'unit-tag'}
+ _toPy = {'port-range': 'port_range', 'relation-tag': 'relation_tag', 'unit-tag': 'unit_tag'}
def __init__(self, port_range=None, relation_tag=None, unit_tag=None):
'''
port_range : PortRange
class MachinePorts(Type):
- _toSchema = {'subnet_tag': 'subnet-tag', 'machine_tag': 'machine-tag'}
- _toPy = {'subnet-tag': 'subnet_tag', 'machine-tag': 'machine_tag'}
+ _toSchema = {'machine_tag': 'machine-tag', 'subnet_tag': 'subnet-tag'}
+ _toPy = {'machine-tag': 'machine_tag', 'subnet-tag': 'subnet_tag'}
def __init__(self, machine_tag=None, subnet_tag=None):
'''
machine_tag : str
class MachinePortsResult(Type):
- _toSchema = {'ports': 'ports', 'error': 'error'}
- _toPy = {'ports': 'ports', 'error': 'error'}
+ _toSchema = {'error': 'error', 'ports': 'ports'}
+ _toPy = {'error': 'error', 'ports': 'ports'}
def __init__(self, error=None, ports=None):
'''
error : Error
self.results = [MachinePortsResult.from_json(o) for o in results or []]
-class NotifyWatchResults(Type):
- _toSchema = {'results': 'results'}
- _toPy = {'results': 'results'}
- def __init__(self, results=None):
- '''
- results : typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
- '''
- self.results = [NotifyWatchResult.from_json(o) for o in results or []]
-
-
class PortRange(Type):
- _toSchema = {'from_port': 'from-port', 'to_port': 'to-port', 'protocol': 'protocol'}
+ _toSchema = {'from_port': 'from-port', 'protocol': 'protocol', 'to_port': 'to-port'}
_toPy = {'from-port': 'from_port', 'protocol': 'protocol', 'to-port': 'to_port'}
def __init__(self, from_port=None, protocol=None, to_port=None):
'''
class ControllersChangeResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class ControllersChanges(Type):
- _toSchema = {'removed': 'removed', 'demoted': 'demoted', 'added': 'added', 'maintained': 'maintained', 'converted': 'converted', 'promoted': 'promoted'}
- _toPy = {'removed': 'removed', 'demoted': 'demoted', 'added': 'added', 'maintained': 'maintained', 'converted': 'converted', 'promoted': 'promoted'}
+ _toSchema = {'added': 'added', 'converted': 'converted', 'demoted': 'demoted', 'maintained': 'maintained', 'promoted': 'promoted', 'removed': 'removed'}
+ _toPy = {'added': 'added', 'converted': 'converted', 'demoted': 'demoted', 'maintained': 'maintained', 'promoted': 'promoted', 'removed': 'removed'}
def __init__(self, added=None, converted=None, demoted=None, maintained=None, promoted=None, removed=None):
'''
added : typing.Sequence<+T_co>[str]
class ControllersSpec(Type):
- _toSchema = {'model_tag': 'model-tag', 'num_controllers': 'num-controllers', 'series': 'series', 'constraints': 'constraints', 'placement': 'placement'}
- _toPy = {'model-tag': 'model_tag', 'placement': 'placement', 'num-controllers': 'num_controllers', 'constraints': 'constraints', 'series': 'series'}
- def __init__(self, constraints=None, model_tag=None, num_controllers=None, placement=None, series=None):
+ _toSchema = {'constraints': 'constraints', 'num_controllers': 'num-controllers', 'placement': 'placement', 'series': 'series'}
+ _toPy = {'constraints': 'constraints', 'num-controllers': 'num_controllers', 'placement': 'placement', 'series': 'series'}
+ def __init__(self, constraints=None, num_controllers=None, placement=None, series=None):
'''
constraints : Value
- model_tag : str
num_controllers : int
placement : typing.Sequence<+T_co>[str]
series : str
'''
self.constraints = Value.from_json(constraints) if constraints else None
- self.model_tag = model_tag
self.num_controllers = num_controllers
self.placement = placement
self.series = series
class HAMember(Type):
- _toSchema = {'tag': 'tag', 'series': 'series', 'public_address': 'public-address'}
- _toPy = {'public-address': 'public_address', 'tag': 'tag', 'series': 'series'}
+ _toSchema = {'public_address': 'public-address', 'series': 'series', 'tag': 'tag'}
+ _toPy = {'public-address': 'public_address', 'series': 'series', 'tag': 'tag'}
def __init__(self, public_address=None, series=None, tag=None):
'''
public_address : Address
class Member(Type):
- _toSchema = {'votes': 'Votes', 'buildindexes': 'BuildIndexes', 'tags': 'Tags', 'arbiter': 'Arbiter', 'address': 'Address', 'priority': 'Priority', 'hidden': 'Hidden', 'id_': 'Id', 'slavedelay': 'SlaveDelay'}
- _toPy = {'Id': 'id_', 'BuildIndexes': 'buildindexes', 'Address': 'address', 'SlaveDelay': 'slavedelay', 'Tags': 'tags', 'Votes': 'votes', 'Priority': 'priority', 'Hidden': 'hidden', 'Arbiter': 'arbiter'}
+ _toSchema = {'address': 'Address', 'arbiter': 'Arbiter', 'buildindexes': 'BuildIndexes', 'hidden': 'Hidden', 'id_': 'Id', 'priority': 'Priority', 'slavedelay': 'SlaveDelay', 'tags': 'Tags', 'votes': 'Votes'}
+ _toPy = {'Address': 'address', 'Arbiter': 'arbiter', 'BuildIndexes': 'buildindexes', 'Hidden': 'hidden', 'Id': 'id_', 'Priority': 'priority', 'SlaveDelay': 'slavedelay', 'Tags': 'tags', 'Votes': 'votes'}
def __init__(self, address=None, arbiter=None, buildindexes=None, hidden=None, id_=None, priority=None, slavedelay=None, tags=None, votes=None):
'''
address : str
class MongoUpgradeResults(Type):
- _toSchema = {'rs_members': 'rs-members', 'ha_members': 'ha-members', 'master': 'master'}
- _toPy = {'ha-members': 'ha_members', 'rs-members': 'rs_members', 'master': 'master'}
+ _toSchema = {'ha_members': 'ha-members', 'master': 'master', 'rs_members': 'rs-members'}
+ _toPy = {'ha-members': 'ha_members', 'master': 'master', 'rs-members': 'rs_members'}
def __init__(self, ha_members=None, master=None, rs_members=None):
'''
ha_members : typing.Sequence<+T_co>[~HAMember]<~HAMember>
self.rs_members = [Member.from_json(o) for o in rs_members or []]
+class MongoVersion(Type):
+ _toSchema = {'engine': 'engine', 'major': 'major', 'minor': 'minor', 'patch': 'patch'}
+ _toPy = {'engine': 'engine', 'major': 'major', 'minor': 'minor', 'patch': 'patch'}
+ def __init__(self, engine=None, major=None, minor=None, patch=None):
+ '''
+ engine : str
+ major : int
+ minor : int
+ patch : str
+ '''
+ self.engine = engine
+ self.major = major
+ self.minor = minor
+ self.patch = patch
+
+
class ResumeReplicationParams(Type):
_toSchema = {'members': 'members'}
_toPy = {'members': 'members'}
class UpgradeMongoParams(Type):
- _toSchema = {'patch': 'Patch', 'minor': 'Minor', 'major': 'Major', 'storageengine': 'StorageEngine'}
- _toPy = {'Major': 'major', 'Minor': 'minor', 'Patch': 'patch', 'StorageEngine': 'storageengine'}
- def __init__(self, major=None, minor=None, patch=None, storageengine=None):
- '''
- major : int
- minor : int
- patch : str
- storageengine : str
- '''
- self.major = major
- self.minor = minor
- self.patch = patch
- self.storageengine = storageengine
-
-
-class Version(Type):
- _toSchema = {'patch': 'Patch', 'minor': 'Minor', 'major': 'Major', 'storageengine': 'StorageEngine'}
- _toPy = {'Major': 'major', 'Minor': 'minor', 'Patch': 'patch', 'StorageEngine': 'storageengine'}
- def __init__(self, major=None, minor=None, patch=None, storageengine=None):
+ _toSchema = {'target': 'target'}
+ _toPy = {'target': 'target'}
+ def __init__(self, target=None):
'''
- major : int
- minor : int
- patch : str
- storageengine : str
+ target : MongoVersion
'''
- self.major = major
- self.minor = minor
- self.patch = patch
- self.storageengine = storageengine
+ self.target = MongoVersion.from_json(target) if target else None
class SSHHostKeySet(Type):
class SSHHostKeys(Type):
- _toSchema = {'tag': 'tag', 'public_keys': 'public-keys'}
- _toPy = {'tag': 'tag', 'public-keys': 'public_keys'}
+ _toSchema = {'public_keys': 'public-keys', 'tag': 'tag'}
+ _toPy = {'public-keys': 'public_keys', 'tag': 'tag'}
def __init__(self, public_keys=None, tag=None):
'''
public_keys : typing.Sequence<+T_co>[str]
class ImageMetadata(Type):
- _toSchema = {'kind': 'kind', 'created': 'created', 'url': 'url', 'series': 'series', 'arch': 'arch'}
- _toPy = {'kind': 'kind', 'created': 'created', 'url': 'url', 'series': 'series', 'arch': 'arch'}
+ _toSchema = {'arch': 'arch', 'created': 'created', 'kind': 'kind', 'series': 'series', 'url': 'url'}
+ _toPy = {'arch': 'arch', 'created': 'created', 'kind': 'kind', 'series': 'series', 'url': 'url'}
def __init__(self, arch=None, created=None, kind=None, series=None, url=None):
'''
arch : str
class ImageSpec(Type):
- _toSchema = {'kind': 'kind', 'series': 'series', 'arch': 'arch'}
- _toPy = {'kind': 'kind', 'series': 'series', 'arch': 'arch'}
+ _toSchema = {'arch': 'arch', 'kind': 'kind', 'series': 'series'}
+ _toPy = {'arch': 'arch', 'kind': 'kind', 'series': 'series'}
def __init__(self, arch=None, kind=None, series=None):
'''
arch : str
class CloudImageMetadata(Type):
- _toSchema = {'image_id': 'image-id', 'source': 'source', 'stream': 'stream', 'root_storage_type': 'root-storage-type', 'virt_type': 'virt-type', 'series': 'series', 'arch': 'arch', 'priority': 'priority', 'region': 'region', 'root_storage_size': 'root-storage-size', 'version': 'version'}
- _toPy = {'source': 'source', 'stream': 'stream', 'series': 'series', 'root-storage-size': 'root_storage_size', 'image-id': 'image_id', 'virt-type': 'virt_type', 'priority': 'priority', 'arch': 'arch', 'region': 'region', 'root-storage-type': 'root_storage_type', 'version': 'version'}
+ _toSchema = {'arch': 'arch', 'image_id': 'image-id', 'priority': 'priority', 'region': 'region', 'root_storage_size': 'root-storage-size', 'root_storage_type': 'root-storage-type', 'series': 'series', 'source': 'source', 'stream': 'stream', 'version': 'version', 'virt_type': 'virt-type'}
+ _toPy = {'arch': 'arch', 'image-id': 'image_id', 'priority': 'priority', 'region': 'region', 'root-storage-size': 'root_storage_size', 'root-storage-type': 'root_storage_type', 'series': 'series', 'source': 'source', 'stream': 'stream', 'version': 'version', 'virt-type': 'virt_type'}
def __init__(self, arch=None, image_id=None, priority=None, region=None, root_storage_size=None, root_storage_type=None, series=None, source=None, stream=None, version=None, virt_type=None):
'''
arch : str
class ImageMetadataFilter(Type):
- _toSchema = {'stream': 'stream', 'root_storage_type': 'root-storage-type', 'virt_type': 'virt-type', 'series': 'series', 'region': 'region', 'arches': 'arches'}
- _toPy = {'stream': 'stream', 'arches': 'arches', 'series': 'series', 'virt-type': 'virt_type', 'region': 'region', 'root-storage-type': 'root_storage_type'}
+ _toSchema = {'arches': 'arches', 'region': 'region', 'root_storage_type': 'root-storage-type', 'series': 'series', 'stream': 'stream', 'virt_type': 'virt-type'}
+ _toPy = {'arches': 'arches', 'region': 'region', 'root-storage-type': 'root_storage_type', 'series': 'series', 'stream': 'stream', 'virt-type': 'virt_type'}
def __init__(self, arches=None, region=None, root_storage_type=None, series=None, stream=None, virt_type=None):
'''
arches : typing.Sequence<+T_co>[str]
self.metadata = [CloudImageMetadataList.from_json(o) for o in metadata or []]
-class EntityStatusArgs(Type):
- _toSchema = {'info': 'info', 'data': 'data', 'tag': 'tag', 'status': 'status'}
- _toPy = {'info': 'info', 'data': 'data', 'tag': 'tag', 'status': 'status'}
- def __init__(self, data=None, info=None, status=None, tag=None):
- '''
- data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
- info : str
- status : str
- tag : str
- '''
- self.data = data
- self.info = info
- self.status = status
- self.tag = tag
-
-
class MachineAddresses(Type):
_toSchema = {'addresses': 'addresses', 'tag': 'tag'}
_toPy = {'addresses': 'addresses', 'tag': 'tag'}
self.machine_addresses = [MachineAddresses.from_json(o) for o in machine_addresses or []]
-class SetStatus(Type):
- _toSchema = {'entities': 'entities'}
- _toPy = {'entities': 'entities'}
- def __init__(self, entities=None):
- '''
- entities : typing.Sequence<+T_co>[~EntityStatusArgs]<~EntityStatusArgs>
- '''
- self.entities = [EntityStatusArgs.from_json(o) for o in entities or []]
-
-
class StatusResult(Type):
- _toSchema = {'info': 'info', 'data': 'data', 'since': 'since', 'error': 'error', 'life': 'life', 'status': 'status', 'id_': 'id'}
- _toPy = {'info': 'info', 'data': 'data', 'since': 'since', 'error': 'error', 'life': 'life', 'status': 'status', 'id': 'id_'}
+ _toSchema = {'data': 'data', 'error': 'error', 'id_': 'id', 'info': 'info', 'life': 'life', 'since': 'since', 'status': 'status'}
+ _toPy = {'data': 'data', 'error': 'error', 'id': 'id_', 'info': 'info', 'life': 'life', 'since': 'since', 'status': 'status'}
def __init__(self, data=None, error=None, id_=None, info=None, life=None, since=None, status=None):
'''
data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
class ModifyUserSSHKeys(Type):
_toSchema = {'ssh_keys': 'ssh-keys', 'user': 'user'}
- _toPy = {'user': 'user', 'ssh-keys': 'ssh_keys'}
+ _toPy = {'ssh-keys': 'ssh_keys', 'user': 'user'}
def __init__(self, ssh_keys=None, user=None):
'''
ssh_keys : typing.Sequence<+T_co>[str]
class ClaimLeadershipParams(Type):
- _toSchema = {'unit_tag': 'unit-tag', 'duration': 'duration', 'application_tag': 'application-tag'}
- _toPy = {'application-tag': 'application_tag', 'unit-tag': 'unit_tag', 'duration': 'duration'}
+ _toSchema = {'application_tag': 'application-tag', 'duration': 'duration', 'unit_tag': 'unit-tag'}
+ _toPy = {'application-tag': 'application_tag', 'duration': 'duration', 'unit-tag': 'unit_tag'}
def __init__(self, application_tag=None, duration=None, unit_tag=None):
'''
application_tag : str
class LogForwardingGetLastSentResult(Type):
- _toSchema = {'record_id': 'record-id', 'record_timestamp': 'record-timestamp', 'err': 'err'}
- _toPy = {'record-timestamp': 'record_timestamp', 'record-id': 'record_id', 'err': 'err'}
+ _toSchema = {'err': 'err', 'record_id': 'record-id', 'record_timestamp': 'record-timestamp'}
+ _toPy = {'err': 'err', 'record-id': 'record_id', 'record-timestamp': 'record_timestamp'}
def __init__(self, err=None, record_id=None, record_timestamp=None):
'''
err : Error
class LogForwardingSetLastSentParam(Type):
- _toSchema = {'record_id': 'record-id', 'logforwardingid': 'LogForwardingID', 'record_timestamp': 'record-timestamp'}
- _toPy = {'record-id': 'record_id', 'LogForwardingID': 'logforwardingid', 'record-timestamp': 'record_timestamp'}
+ _toSchema = {'logforwardingid': 'LogForwardingID', 'record_id': 'record-id', 'record_timestamp': 'record-timestamp'}
+ _toPy = {'LogForwardingID': 'logforwardingid', 'record-id': 'record_id', 'record-timestamp': 'record_timestamp'}
def __init__(self, logforwardingid=None, record_id=None, record_timestamp=None):
'''
logforwardingid : LogForwardingID
class ActionExecutionResult(Type):
- _toSchema = {'status': 'status', 'action_tag': 'action-tag', 'results': 'results', 'message': 'message'}
- _toPy = {'status': 'status', 'results': 'results', 'action-tag': 'action_tag', 'message': 'message'}
+ _toSchema = {'action_tag': 'action-tag', 'message': 'message', 'results': 'results', 'status': 'status'}
+ _toPy = {'action-tag': 'action_tag', 'message': 'message', 'results': 'results', 'status': 'status'}
def __init__(self, action_tag=None, message=None, results=None, status=None):
'''
action_tag : str
class ProviderInterfaceInfo(Type):
- _toSchema = {'provider_id': 'provider-id', 'mac_address': 'mac-address', 'interface_name': 'interface-name'}
+ _toSchema = {'interface_name': 'interface-name', 'mac_address': 'mac-address', 'provider_id': 'provider-id'}
_toPy = {'interface-name': 'interface_name', 'mac-address': 'mac_address', 'provider-id': 'provider_id'}
def __init__(self, interface_name=None, mac_address=None, provider_id=None):
'''
class ProviderInterfaceInfoResult(Type):
- _toSchema = {'interfaces': 'interfaces', 'machine_tag': 'machine-tag', 'error': 'error'}
- _toPy = {'interfaces': 'interfaces', 'machine-tag': 'machine_tag', 'error': 'error'}
+ _toSchema = {'error': 'error', 'interfaces': 'interfaces', 'machine_tag': 'machine-tag'}
+ _toPy = {'error': 'error', 'interfaces': 'interfaces', 'machine-tag': 'machine_tag'}
def __init__(self, error=None, interfaces=None, machine_tag=None):
'''
error : Error
class JobsResult(Type):
- _toSchema = {'jobs': 'jobs', 'error': 'error'}
- _toPy = {'jobs': 'jobs', 'error': 'error'}
+ _toSchema = {'error': 'error', 'jobs': 'jobs'}
+ _toPy = {'error': 'error', 'jobs': 'jobs'}
def __init__(self, error=None, jobs=None):
'''
error : Error
class NetworkConfig(Type):
- _toSchema = {'provider_address_id': 'provider-address-id', 'provider_id': 'provider-id', 'cidr': 'cidr', 'config_type': 'config-type', 'disabled': 'disabled', 'address': 'address', 'provider_vlan_id': 'provider-vlan-id', 'dns_servers': 'dns-servers', 'interface_type': 'interface-type', 'mac_address': 'mac-address', 'no_auto_start': 'no-auto-start', 'dns_search_domains': 'dns-search-domains', 'provider_subnet_id': 'provider-subnet-id', 'device_index': 'device-index', 'interface_name': 'interface-name', 'parent_interface_name': 'parent-interface-name', 'mtu': 'mtu', 'gateway_address': 'gateway-address', 'provider_space_id': 'provider-space-id', 'vlan_tag': 'vlan-tag'}
- _toPy = {'provider-vlan-id': 'provider_vlan_id', 'interface-name': 'interface_name', 'gateway-address': 'gateway_address', 'no-auto-start': 'no_auto_start', 'address': 'address', 'parent-interface-name': 'parent_interface_name', 'provider-subnet-id': 'provider_subnet_id', 'dns-search-domains': 'dns_search_domains', 'dns-servers': 'dns_servers', 'interface-type': 'interface_type', 'provider-space-id': 'provider_space_id', 'mac-address': 'mac_address', 'device-index': 'device_index', 'disabled': 'disabled', 'config-type': 'config_type', 'provider-address-id': 'provider_address_id', 'mtu': 'mtu', 'cidr': 'cidr', 'vlan-tag': 'vlan_tag', 'provider-id': 'provider_id'}
+ _toSchema = {'address': 'address', 'cidr': 'cidr', 'config_type': 'config-type', 'device_index': 'device-index', 'disabled': 'disabled', 'dns_search_domains': 'dns-search-domains', 'dns_servers': 'dns-servers', 'gateway_address': 'gateway-address', 'interface_name': 'interface-name', 'interface_type': 'interface-type', 'mac_address': 'mac-address', 'mtu': 'mtu', 'no_auto_start': 'no-auto-start', 'parent_interface_name': 'parent-interface-name', 'provider_address_id': 'provider-address-id', 'provider_id': 'provider-id', 'provider_space_id': 'provider-space-id', 'provider_subnet_id': 'provider-subnet-id', 'provider_vlan_id': 'provider-vlan-id', 'vlan_tag': 'vlan-tag'}
+ _toPy = {'address': 'address', 'cidr': 'cidr', 'config-type': 'config_type', 'device-index': 'device_index', 'disabled': 'disabled', 'dns-search-domains': 'dns_search_domains', 'dns-servers': 'dns_servers', 'gateway-address': 'gateway_address', 'interface-name': 'interface_name', 'interface-type': 'interface_type', 'mac-address': 'mac_address', 'mtu': 'mtu', 'no-auto-start': 'no_auto_start', 'parent-interface-name': 'parent_interface_name', 'provider-address-id': 'provider_address_id', 'provider-id': 'provider_id', 'provider-space-id': 'provider_space_id', 'provider-subnet-id': 'provider_subnet_id', 'provider-vlan-id': 'provider_vlan_id', 'vlan-tag': 'vlan_tag'}
def __init__(self, address=None, cidr=None, config_type=None, device_index=None, disabled=None, dns_search_domains=None, dns_servers=None, gateway_address=None, interface_name=None, interface_type=None, mac_address=None, mtu=None, no_auto_start=None, parent_interface_name=None, provider_address_id=None, provider_id=None, provider_space_id=None, provider_subnet_id=None, provider_vlan_id=None, vlan_tag=None):
'''
address : str
class MeterStatusResult(Type):
- _toSchema = {'info': 'info', 'code': 'code', 'error': 'error'}
- _toPy = {'info': 'info', 'code': 'code', 'error': 'error'}
+ _toSchema = {'code': 'code', 'error': 'error', 'info': 'info'}
+ _toPy = {'code': 'code', 'error': 'error', 'info': 'info'}
def __init__(self, code=None, error=None, info=None):
'''
code : str
class Metric(Type):
- _toSchema = {'time': 'time', 'value': 'value', 'key': 'key'}
- _toPy = {'time': 'time', 'value': 'value', 'key': 'key'}
+ _toSchema = {'key': 'key', 'time': 'time', 'value': 'value'}
+ _toPy = {'key': 'key', 'time': 'time', 'value': 'value'}
def __init__(self, key=None, time=None, value=None):
'''
key : str
class MetricBatch(Type):
- _toSchema = {'uuid': 'uuid', 'created': 'created', 'charm_url': 'charm-url', 'metrics': 'metrics'}
- _toPy = {'uuid': 'uuid', 'charm-url': 'charm_url', 'created': 'created', 'metrics': 'metrics'}
+ _toSchema = {'charm_url': 'charm-url', 'created': 'created', 'metrics': 'metrics', 'uuid': 'uuid'}
+ _toPy = {'charm-url': 'charm_url', 'created': 'created', 'metrics': 'metrics', 'uuid': 'uuid'}
def __init__(self, charm_url=None, created=None, metrics=None, uuid=None):
'''
charm_url : str
class EntityMetrics(Type):
- _toSchema = {'metrics': 'metrics', 'error': 'error'}
- _toPy = {'metrics': 'metrics', 'error': 'error'}
+ _toSchema = {'error': 'error', 'metrics': 'metrics'}
+ _toPy = {'error': 'error', 'metrics': 'metrics'}
def __init__(self, error=None, metrics=None):
'''
error : Error
class MeterStatusParam(Type):
- _toSchema = {'info': 'info', 'tag': 'tag', 'code': 'code'}
- _toPy = {'info': 'info', 'tag': 'tag', 'code': 'code'}
+ _toSchema = {'code': 'code', 'info': 'info', 'tag': 'tag'}
+ _toPy = {'code': 'code', 'info': 'info', 'tag': 'tag'}
def __init__(self, code=None, info=None, tag=None):
'''
code : str
class MetricResult(Type):
- _toSchema = {'time': 'time', 'value': 'value', 'key': 'key'}
- _toPy = {'time': 'time', 'value': 'value', 'key': 'key'}
- def __init__(self, key=None, time=None, value=None):
+ _toSchema = {'key': 'key', 'time': 'time', 'unit': 'unit', 'value': 'value'}
+ _toPy = {'key': 'key', 'time': 'time', 'unit': 'unit', 'value': 'value'}
+ def __init__(self, key=None, time=None, unit=None, value=None):
'''
key : str
time : str
+ unit : str
value : str
'''
self.key = key
self.time = time
+ self.unit = unit
self.value = value
class PhaseResult(Type):
- _toSchema = {'phase': 'phase', 'error': 'error'}
- _toPy = {'phase': 'phase', 'error': 'error'}
+ _toSchema = {'error': 'error', 'phase': 'phase'}
+ _toPy = {'error': 'error', 'phase': 'phase'}
def __init__(self, error=None, phase=None):
'''
error : Error
class MasterMigrationStatus(Type):
- _toSchema = {'phase': 'phase', 'phase_changed_time': 'phase-changed-time', 'migration_id': 'migration-id', 'spec': 'spec'}
- _toPy = {'phase': 'phase', 'phase-changed-time': 'phase_changed_time', 'migration-id': 'migration_id', 'spec': 'spec'}
+ _toSchema = {'migration_id': 'migration-id', 'phase': 'phase', 'phase_changed_time': 'phase-changed-time', 'spec': 'spec'}
+ _toPy = {'migration-id': 'migration_id', 'phase': 'phase', 'phase-changed-time': 'phase_changed_time', 'spec': 'spec'}
def __init__(self, migration_id=None, phase=None, phase_changed_time=None, spec=None):
'''
migration_id : str
class MigrationModelInfo(Type):
- _toSchema = {'agent_version': 'agent-version', 'uuid': 'uuid', 'name': 'name'}
- _toPy = {'name': 'name', 'uuid': 'uuid', 'agent-version': 'agent_version'}
- def __init__(self, agent_version=None, name=None, uuid=None):
+ _toSchema = {'agent_version': 'agent-version', 'name': 'name', 'owner_tag': 'owner-tag', 'uuid': 'uuid'}
+ _toPy = {'agent-version': 'agent_version', 'name': 'name', 'owner-tag': 'owner_tag', 'uuid': 'uuid'}
+ def __init__(self, agent_version=None, name=None, owner_tag=None, uuid=None):
'''
agent_version : Number
name : str
+ owner_tag : str
uuid : str
'''
self.agent_version = Number.from_json(agent_version) if agent_version else None
self.name = name
+ self.owner_tag = owner_tag
self.uuid = uuid
class MinionReports(Type):
- _toSchema = {'unknown_sample': 'unknown-sample', 'phase': 'phase', 'failed': 'failed', 'success_count': 'success-count', 'migration_id': 'migration-id', 'unknown_count': 'unknown-count'}
- _toPy = {'phase': 'phase', 'failed': 'failed', 'success-count': 'success_count', 'migration-id': 'migration_id', 'unknown-sample': 'unknown_sample', 'unknown-count': 'unknown_count'}
+ _toSchema = {'failed': 'failed', 'migration_id': 'migration-id', 'phase': 'phase', 'success_count': 'success-count', 'unknown_count': 'unknown-count', 'unknown_sample': 'unknown-sample'}
+ _toPy = {'failed': 'failed', 'migration-id': 'migration_id', 'phase': 'phase', 'success-count': 'success_count', 'unknown-count': 'unknown_count', 'unknown-sample': 'unknown_sample'}
def __init__(self, failed=None, migration_id=None, phase=None, success_count=None, unknown_count=None, unknown_sample=None):
'''
failed : typing.Sequence<+T_co>[str]
class SerializedModel(Type):
- _toSchema = {'charms': 'charms', 'bytes_': 'bytes', 'tools': 'tools'}
- _toPy = {'charms': 'charms', 'tools': 'tools', 'bytes': 'bytes_'}
+ _toSchema = {'bytes_': 'bytes', 'charms': 'charms', 'tools': 'tools'}
+ _toPy = {'bytes': 'bytes_', 'charms': 'charms', 'tools': 'tools'}
def __init__(self, bytes_=None, charms=None, tools=None):
'''
bytes_ : typing.Sequence<+T_co>[int]
class MinionReport(Type):
- _toSchema = {'success': 'success', 'phase': 'phase', 'migration_id': 'migration-id'}
- _toPy = {'success': 'success', 'phase': 'phase', 'migration-id': 'migration_id'}
+ _toSchema = {'migration_id': 'migration-id', 'phase': 'phase', 'success': 'success'}
+ _toPy = {'migration-id': 'migration_id', 'phase': 'phase', 'success': 'success'}
def __init__(self, migration_id=None, phase=None, success=None):
'''
migration_id : str
class MigrationStatus(Type):
- _toSchema = {'target_ca_cert': 'target-ca-cert', 'phase': 'phase', 'target_api_addrs': 'target-api-addrs', 'source_api_addrs': 'source-api-addrs', 'attempt': 'attempt', 'migration_id': 'migration-id', 'source_ca_cert': 'source-ca-cert'}
- _toPy = {'phase': 'phase', 'source-ca-cert': 'source_ca_cert', 'target-api-addrs': 'target_api_addrs', 'target-ca-cert': 'target_ca_cert', 'source-api-addrs': 'source_api_addrs', 'attempt': 'attempt', 'migration-id': 'migration_id'}
- def __init__(self, attempt=None, migration_id=None, phase=None, source_api_addrs=None, source_ca_cert=None, target_api_addrs=None, target_ca_cert=None):
+ _toSchema = {'attempt': 'attempt', 'external_control': 'external-control', 'migration_id': 'migration-id', 'phase': 'phase', 'source_api_addrs': 'source-api-addrs', 'source_ca_cert': 'source-ca-cert', 'target_api_addrs': 'target-api-addrs', 'target_ca_cert': 'target-ca-cert'}
+ _toPy = {'attempt': 'attempt', 'external-control': 'external_control', 'migration-id': 'migration_id', 'phase': 'phase', 'source-api-addrs': 'source_api_addrs', 'source-ca-cert': 'source_ca_cert', 'target-api-addrs': 'target_api_addrs', 'target-ca-cert': 'target_ca_cert'}
+ def __init__(self, attempt=None, external_control=None, migration_id=None, phase=None, source_api_addrs=None, source_ca_cert=None, target_api_addrs=None, target_ca_cert=None):
'''
attempt : int
+ external_control : bool
migration_id : str
phase : str
source_api_addrs : typing.Sequence<+T_co>[str]
target_ca_cert : str
'''
self.attempt = attempt
+ self.external_control = external_control
self.migration_id = migration_id
self.phase = phase
self.source_api_addrs = source_api_addrs
self.model_tag = model_tag
-class TargetPrechecksArgs(Type):
- _toSchema = {'build': 'Build', 'patch': 'Patch', 'tag': 'Tag', 'minor': 'Minor', 'major': 'Major'}
- _toPy = {'Tag': 'tag', 'Major': 'major', 'Patch': 'patch', 'Minor': 'minor', 'Build': 'build'}
- def __init__(self, build=None, major=None, minor=None, patch=None, tag=None):
- '''
- build : int
- major : int
- minor : int
- patch : int
- tag : str
- '''
- self.build = build
- self.major = major
- self.minor = minor
- self.patch = patch
- self.tag = tag
-
-
class MapResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class ModelCreateArgs(Type):
- _toSchema = {'config': 'config', 'cloud_tag': 'cloud-tag', 'owner_tag': 'owner-tag', 'region': 'region', 'name': 'name', 'credential': 'credential'}
- _toPy = {'config': 'config', 'region': 'region', 'name': 'name', 'owner-tag': 'owner_tag', 'cloud-tag': 'cloud_tag', 'credential': 'credential'}
+ _toSchema = {'cloud_tag': 'cloud-tag', 'config': 'config', 'credential': 'credential', 'name': 'name', 'owner_tag': 'owner-tag', 'region': 'region'}
+ _toPy = {'cloud-tag': 'cloud_tag', 'config': 'config', 'credential': 'credential', 'name': 'name', 'owner-tag': 'owner_tag', 'region': 'region'}
def __init__(self, cloud_tag=None, config=None, credential=None, name=None, owner_tag=None, region=None):
'''
cloud_tag : str
self.region = region
+class ModelDefaultValues(Type):
+ _toSchema = {'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'config': 'config'}
+ _toPy = {'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'config': 'config'}
+ def __init__(self, cloud_region=None, cloud_tag=None, config=None):
+ '''
+ cloud_region : str
+ cloud_tag : str
+ config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ '''
+ self.cloud_region = cloud_region
+ self.cloud_tag = cloud_tag
+ self.config = config
+
+
+class ModelDefaults(Type):
+ _toSchema = {'controller': 'controller', 'default': 'default', 'regions': 'regions'}
+ _toPy = {'controller': 'controller', 'default': 'default', 'regions': 'regions'}
+ def __init__(self, controller=None, default=None, regions=None):
+ '''
+ controller : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ default : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ regions : typing.Sequence<+T_co>[~RegionDefaults]<~RegionDefaults>
+ '''
+ self.controller = controller
+ self.default = default
+ self.regions = [RegionDefaults.from_json(o) for o in regions or []]
+
+
+class ModelDefaultsResult(Type):
+ _toSchema = {'config': 'config'}
+ _toPy = {'config': 'config'}
+ def __init__(self, config=None):
+ '''
+ config : typing.Mapping<~KT, +VT_co>[str, ~ModelDefaults]<~ModelDefaults>
+ '''
+ self.config = config
+
+
class ModelInfoResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
self.results = [ModelInfoResult.from_json(o) for o in results or []]
+class ModelUnsetKeys(Type):
+ _toSchema = {'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'keys': 'keys'}
+ _toPy = {'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'keys': 'keys'}
+ def __init__(self, cloud_region=None, cloud_tag=None, keys=None):
+ '''
+ cloud_region : str
+ cloud_tag : str
+ keys : typing.Sequence<+T_co>[str]
+ '''
+ self.cloud_region = cloud_region
+ self.cloud_tag = cloud_tag
+ self.keys = keys
+
+
class ModifyModelAccess(Type):
- _toSchema = {'model_tag': 'model-tag', 'access': 'access', 'action': 'action', 'user_tag': 'user-tag'}
- _toPy = {'model-tag': 'model_tag', 'access': 'access', 'action': 'action', 'user-tag': 'user_tag'}
+ _toSchema = {'access': 'access', 'action': 'action', 'model_tag': 'model-tag', 'user_tag': 'user-tag'}
+ _toPy = {'access': 'access', 'action': 'action', 'model-tag': 'model_tag', 'user-tag': 'user_tag'}
def __init__(self, access=None, action=None, model_tag=None, user_tag=None):
'''
access : str
self.changes = [ModifyModelAccess.from_json(o) for o in changes or []]
+class RegionDefaults(Type):
+ _toSchema = {'region_name': 'region-name', 'value': 'value'}
+ _toPy = {'region-name': 'region_name', 'value': 'value'}
+ def __init__(self, region_name=None, value=None):
+ '''
+ region_name : str
+ value : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ '''
+ self.region_name = region_name
+ self.value = value
+
+
+class SetModelDefaults(Type):
+ _toSchema = {'config': 'config'}
+ _toPy = {'config': 'config'}
+ def __init__(self, config=None):
+ '''
+ config : typing.Sequence<+T_co>[~ModelDefaultValues]<~ModelDefaultValues>
+ '''
+ self.config = [ModelDefaultValues.from_json(o) for o in config or []]
+
+
+class UnsetModelDefaults(Type):
+ _toSchema = {'keys': 'keys'}
+ _toPy = {'keys': 'keys'}
+ def __init__(self, keys=None):
+ '''
+ keys : typing.Sequence<+T_co>[~ModelUnsetKeys]<~ModelUnsetKeys>
+ '''
+ self.keys = [ModelUnsetKeys.from_json(o) for o in keys or []]
+
+
class ConstraintsResult(Type):
_toSchema = {'constraints': 'constraints', 'error': 'error'}
_toPy = {'constraints': 'constraints', 'error': 'error'}
class ContainerConfig(Type):
- _toSchema = {'updatebehavior': 'UpdateBehavior', 'authorized_keys': 'authorized-keys', 'apt_mirror': 'apt-mirror', 'proxy': 'proxy', 'ssl_hostname_verification': 'ssl-hostname-verification', 'provider_type': 'provider-type', 'apt_proxy': 'apt-proxy'}
- _toPy = {'ssl-hostname-verification': 'ssl_hostname_verification', 'apt-proxy': 'apt_proxy', 'proxy': 'proxy', 'apt-mirror': 'apt_mirror', 'UpdateBehavior': 'updatebehavior', 'authorized-keys': 'authorized_keys', 'provider-type': 'provider_type'}
+ _toSchema = {'apt_mirror': 'apt-mirror', 'apt_proxy': 'apt-proxy', 'authorized_keys': 'authorized-keys', 'provider_type': 'provider-type', 'proxy': 'proxy', 'ssl_hostname_verification': 'ssl-hostname-verification', 'updatebehavior': 'UpdateBehavior'}
+ _toPy = {'UpdateBehavior': 'updatebehavior', 'apt-mirror': 'apt_mirror', 'apt-proxy': 'apt_proxy', 'authorized-keys': 'authorized_keys', 'provider-type': 'provider_type', 'proxy': 'proxy', 'ssl-hostname-verification': 'ssl_hostname_verification'}
def __init__(self, updatebehavior=None, apt_mirror=None, apt_proxy=None, authorized_keys=None, provider_type=None, proxy=None, ssl_hostname_verification=None):
'''
updatebehavior : UpdateBehavior
class DistributionGroupResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class InstanceInfo(Type):
- _toSchema = {'volumes': 'volumes', 'nonce': 'nonce', 'characteristics': 'characteristics', 'instance_id': 'instance-id', 'network_config': 'network-config', 'tag': 'tag', 'volume_attachments': 'volume-attachments'}
- _toPy = {'network-config': 'network_config', 'nonce': 'nonce', 'characteristics': 'characteristics', 'instance-id': 'instance_id', 'tag': 'tag', 'volumes': 'volumes', 'volume-attachments': 'volume_attachments'}
+ _toSchema = {'characteristics': 'characteristics', 'instance_id': 'instance-id', 'network_config': 'network-config', 'nonce': 'nonce', 'tag': 'tag', 'volume_attachments': 'volume-attachments', 'volumes': 'volumes'}
+ _toPy = {'characteristics': 'characteristics', 'instance-id': 'instance_id', 'network-config': 'network_config', 'nonce': 'nonce', 'tag': 'tag', 'volume-attachments': 'volume_attachments', 'volumes': 'volumes'}
def __init__(self, characteristics=None, instance_id=None, network_config=None, nonce=None, tag=None, volume_attachments=None, volumes=None):
'''
characteristics : HardwareCharacteristics
class MachineContainers(Type):
- _toSchema = {'machine_tag': 'machine-tag', 'container_types': 'container-types'}
- _toPy = {'machine-tag': 'machine_tag', 'container-types': 'container_types'}
+ _toSchema = {'container_types': 'container-types', 'machine_tag': 'machine-tag'}
+ _toPy = {'container-types': 'container_types', 'machine-tag': 'machine_tag'}
def __init__(self, container_types=None, machine_tag=None):
'''
container_types : typing.Sequence<+T_co>[str]
class MachineNetworkConfigResult(Type):
- _toSchema = {'info': 'info', 'error': 'error'}
- _toPy = {'info': 'info', 'error': 'error'}
+ _toSchema = {'error': 'error', 'info': 'info'}
+ _toPy = {'error': 'error', 'info': 'info'}
def __init__(self, error=None, info=None):
'''
error : Error
class ProvisioningInfo(Type):
- _toSchema = {'tags': 'tags', 'volumes': 'volumes', 'controller_config': 'controller-config', 'constraints': 'constraints', 'series': 'series', 'placement': 'placement', 'endpoint_bindings': 'endpoint-bindings', 'subnets_to_zones': 'subnets-to-zones', 'image_metadata': 'image-metadata', 'jobs': 'jobs'}
- _toPy = {'image-metadata': 'image_metadata', 'volumes': 'volumes', 'constraints': 'constraints', 'series': 'series', 'subnets-to-zones': 'subnets_to_zones', 'placement': 'placement', 'controller-config': 'controller_config', 'endpoint-bindings': 'endpoint_bindings', 'jobs': 'jobs', 'tags': 'tags'}
+ _toSchema = {'constraints': 'constraints', 'controller_config': 'controller-config', 'endpoint_bindings': 'endpoint-bindings', 'image_metadata': 'image-metadata', 'jobs': 'jobs', 'placement': 'placement', 'series': 'series', 'subnets_to_zones': 'subnets-to-zones', 'tags': 'tags', 'volumes': 'volumes'}
+ _toPy = {'constraints': 'constraints', 'controller-config': 'controller_config', 'endpoint-bindings': 'endpoint_bindings', 'image-metadata': 'image_metadata', 'jobs': 'jobs', 'placement': 'placement', 'series': 'series', 'subnets-to-zones': 'subnets_to_zones', 'tags': 'tags', 'volumes': 'volumes'}
def __init__(self, constraints=None, controller_config=None, endpoint_bindings=None, image_metadata=None, jobs=None, placement=None, series=None, subnets_to_zones=None, tags=None, volumes=None):
'''
constraints : Value
class ProvisioningInfoResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class Settings(Type):
- _toSchema = {'https': 'Https', 'ftp': 'Ftp', 'noproxy': 'NoProxy', 'http': 'Http'}
- _toPy = {'Http': 'http', 'Https': 'https', 'Ftp': 'ftp', 'NoProxy': 'noproxy'}
+ _toSchema = {'ftp': 'Ftp', 'http': 'Http', 'https': 'Https', 'noproxy': 'NoProxy'}
+ _toPy = {'Ftp': 'ftp', 'Http': 'http', 'Https': 'https', 'NoProxy': 'noproxy'}
def __init__(self, ftp=None, http=None, https=None, noproxy=None):
'''
ftp : str
class ToolsResult(Type):
- _toSchema = {'disable_ssl_hostname_verification': 'disable-ssl-hostname-verification', 'tools': 'tools', 'error': 'error'}
- _toPy = {'disable-ssl-hostname-verification': 'disable_ssl_hostname_verification', 'tools': 'tools', 'error': 'error'}
+ _toSchema = {'disable_ssl_hostname_verification': 'disable-ssl-hostname-verification', 'error': 'error', 'tools': 'tools'}
+ _toPy = {'disable-ssl-hostname-verification': 'disable_ssl_hostname_verification', 'error': 'error', 'tools': 'tools'}
def __init__(self, disable_ssl_hostname_verification=None, error=None, tools=None):
'''
disable_ssl_hostname_verification : bool
class UpdateBehavior(Type):
- _toSchema = {'enable_os_upgrade': 'enable-os-upgrade', 'enable_os_refresh_update': 'enable-os-refresh-update'}
+ _toSchema = {'enable_os_refresh_update': 'enable-os-refresh-update', 'enable_os_upgrade': 'enable-os-upgrade'}
_toPy = {'enable-os-refresh-update': 'enable_os_refresh_update', 'enable-os-upgrade': 'enable_os_upgrade'}
def __init__(self, enable_os_refresh_update=None, enable_os_upgrade=None):
'''
class VolumeAttachmentInfo(Type):
- _toSchema = {'bus_address': 'bus-address', 'device_name': 'device-name', 'device_link': 'device-link', 'read_only': 'read-only'}
- _toPy = {'device-link': 'device_link', 'read-only': 'read_only', 'device-name': 'device_name', 'bus-address': 'bus_address'}
+ _toSchema = {'bus_address': 'bus-address', 'device_link': 'device-link', 'device_name': 'device-name', 'read_only': 'read-only'}
+ _toPy = {'bus-address': 'bus_address', 'device-link': 'device_link', 'device-name': 'device_name', 'read-only': 'read_only'}
def __init__(self, bus_address=None, device_link=None, device_name=None, read_only=None):
'''
bus_address : str
class VolumeAttachmentParams(Type):
- _toSchema = {'read_only': 'read-only', 'volume_id': 'volume-id', 'instance_id': 'instance-id', 'provider': 'provider', 'volume_tag': 'volume-tag', 'machine_tag': 'machine-tag'}
- _toPy = {'instance-id': 'instance_id', 'volume-id': 'volume_id', 'read-only': 'read_only', 'machine-tag': 'machine_tag', 'provider': 'provider', 'volume-tag': 'volume_tag'}
+ _toSchema = {'instance_id': 'instance-id', 'machine_tag': 'machine-tag', 'provider': 'provider', 'read_only': 'read-only', 'volume_id': 'volume-id', 'volume_tag': 'volume-tag'}
+ _toPy = {'instance-id': 'instance_id', 'machine-tag': 'machine_tag', 'provider': 'provider', 'read-only': 'read_only', 'volume-id': 'volume_id', 'volume-tag': 'volume_tag'}
def __init__(self, instance_id=None, machine_tag=None, provider=None, read_only=None, volume_id=None, volume_tag=None):
'''
instance_id : str
class VolumeInfo(Type):
- _toSchema = {'hardware_id': 'hardware-id', 'persistent': 'persistent', 'volume_id': 'volume-id', 'size': 'size'}
- _toPy = {'persistent': 'persistent', 'size': 'size', 'volume-id': 'volume_id', 'hardware-id': 'hardware_id'}
+ _toSchema = {'hardware_id': 'hardware-id', 'persistent': 'persistent', 'size': 'size', 'volume_id': 'volume-id'}
+ _toPy = {'hardware-id': 'hardware_id', 'persistent': 'persistent', 'size': 'size', 'volume-id': 'volume_id'}
def __init__(self, hardware_id=None, persistent=None, size=None, volume_id=None):
'''
hardware_id : str
class VolumeParams(Type):
- _toSchema = {'attachment': 'attachment', 'size': 'size', 'tags': 'tags', 'attributes': 'attributes', 'provider': 'provider', 'volume_tag': 'volume-tag'}
- _toPy = {'attachment': 'attachment', 'size': 'size', 'tags': 'tags', 'attributes': 'attributes', 'provider': 'provider', 'volume-tag': 'volume_tag'}
+ _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume_tag': 'volume-tag'}
+ _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume-tag': 'volume_tag'}
def __init__(self, attachment=None, attributes=None, provider=None, size=None, tags=None, volume_tag=None):
'''
attachment : VolumeAttachmentParams
class WatchContainer(Type):
- _toSchema = {'machine_tag': 'machine-tag', 'container_type': 'container-type'}
- _toPy = {'machine-tag': 'machine_tag', 'container-type': 'container_type'}
+ _toSchema = {'container_type': 'container-type', 'machine_tag': 'machine-tag'}
+ _toPy = {'container-type': 'container_type', 'machine-tag': 'machine_tag'}
def __init__(self, container_type=None, machine_tag=None):
'''
container_type : str
class ProxyConfig(Type):
- _toSchema = {'https': 'https', 'ftp': 'ftp', 'no_proxy': 'no-proxy', 'http': 'http'}
- _toPy = {'https': 'https', 'ftp': 'ftp', 'no-proxy': 'no_proxy', 'http': 'http'}
+ _toSchema = {'ftp': 'ftp', 'http': 'http', 'https': 'https', 'no_proxy': 'no-proxy'}
+ _toPy = {'ftp': 'ftp', 'http': 'http', 'https': 'https', 'no-proxy': 'no_proxy'}
def __init__(self, ftp=None, http=None, https=None, no_proxy=None):
'''
ftp : str
class ProxyConfigResult(Type):
- _toSchema = {'proxy_settings': 'proxy-settings', 'apt_proxy_settings': 'apt-proxy-settings', 'error': 'error'}
- _toPy = {'proxy-settings': 'proxy_settings', 'error': 'error', 'apt-proxy-settings': 'apt_proxy_settings'}
+ _toSchema = {'apt_proxy_settings': 'apt-proxy-settings', 'error': 'error', 'proxy_settings': 'proxy-settings'}
+ _toPy = {'apt-proxy-settings': 'apt_proxy_settings', 'error': 'error', 'proxy-settings': 'proxy_settings'}
def __init__(self, apt_proxy_settings=None, error=None, proxy_settings=None):
'''
apt_proxy_settings : ProxyConfig
class RebootActionResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class RelationUnitsChange(Type):
- _toSchema = {'departed': 'departed', 'changed': 'changed'}
- _toPy = {'departed': 'departed', 'changed': 'changed'}
+ _toSchema = {'changed': 'changed', 'departed': 'departed'}
+ _toPy = {'changed': 'changed', 'departed': 'departed'}
def __init__(self, changed=None, departed=None):
'''
changed : typing.Mapping<~KT, +VT_co>[str, ~UnitSettings]<~UnitSettings>
class RelationUnitsWatchResult(Type):
- _toSchema = {'changes': 'changes', 'watcher_id': 'watcher-id', 'error': 'error'}
- _toPy = {'watcher-id': 'watcher_id', 'changes': 'changes', 'error': 'error'}
+ _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
+ _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
def __init__(self, changes=None, error=None, watcher_id=None):
'''
changes : RelationUnitsChange
class RetryStrategy(Type):
- _toSchema = {'max_retry_time': 'max-retry-time', 'should_retry': 'should-retry', 'jitter_retry_time': 'jitter-retry-time', 'min_retry_time': 'min-retry-time', 'retry_time_factor': 'retry-time-factor'}
- _toPy = {'max-retry-time': 'max_retry_time', 'min-retry-time': 'min_retry_time', 'jitter-retry-time': 'jitter_retry_time', 'should-retry': 'should_retry', 'retry-time-factor': 'retry_time_factor'}
+ _toSchema = {'jitter_retry_time': 'jitter-retry-time', 'max_retry_time': 'max-retry-time', 'min_retry_time': 'min-retry-time', 'retry_time_factor': 'retry-time-factor', 'should_retry': 'should-retry'}
+ _toPy = {'jitter-retry-time': 'jitter_retry_time', 'max-retry-time': 'max_retry_time', 'min-retry-time': 'min_retry_time', 'retry-time-factor': 'retry_time_factor', 'should-retry': 'should_retry'}
def __init__(self, jitter_retry_time=None, max_retry_time=None, min_retry_time=None, retry_time_factor=None, should_retry=None):
'''
jitter_retry_time : bool
class RetryStrategyResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class SSHAddressResult(Type):
- _toSchema = {'error': 'error', 'address': 'address'}
- _toPy = {'error': 'error', 'address': 'address'}
+ _toSchema = {'address': 'address', 'error': 'error'}
+ _toPy = {'address': 'address', 'error': 'error'}
def __init__(self, address=None, error=None):
'''
address : str
self.results = [SSHAddressResult.from_json(o) for o in results or []]
+class SSHAddressesResult(Type):
+ _toSchema = {'addresses': 'addresses', 'error': 'error'}
+ _toPy = {'addresses': 'addresses', 'error': 'error'}
+ def __init__(self, addresses=None, error=None):
+ '''
+ addresses : typing.Sequence<+T_co>[str]
+ error : Error
+ '''
+ self.addresses = addresses
+ self.error = Error.from_json(error) if error else None
+
+
+class SSHAddressesResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~SSHAddressesResult]<~SSHAddressesResult>
+ '''
+ self.results = [SSHAddressesResult.from_json(o) for o in results or []]
+
+
class SSHProxyResult(Type):
_toSchema = {'use_proxy': 'use-proxy'}
_toPy = {'use-proxy': 'use_proxy'}
class SSHPublicKeysResult(Type):
- _toSchema = {'public_keys': 'public-keys', 'error': 'error'}
- _toPy = {'public-keys': 'public_keys', 'error': 'error'}
+ _toSchema = {'error': 'error', 'public_keys': 'public-keys'}
+ _toPy = {'error': 'error', 'public-keys': 'public_keys'}
def __init__(self, error=None, public_keys=None):
'''
error : Error
class SingularClaim(Type):
- _toSchema = {'model_tag': 'model-tag', 'duration': 'duration', 'controller_tag': 'controller-tag'}
- _toPy = {'model-tag': 'model_tag', 'controller-tag': 'controller_tag', 'duration': 'duration'}
+ _toSchema = {'controller_tag': 'controller-tag', 'duration': 'duration', 'model_tag': 'model-tag'}
+ _toPy = {'controller-tag': 'controller_tag', 'duration': 'duration', 'model-tag': 'model_tag'}
def __init__(self, controller_tag=None, duration=None, model_tag=None):
'''
controller_tag : str
class Space(Type):
- _toSchema = {'name': 'name', 'subnets': 'subnets', 'error': 'error'}
- _toPy = {'name': 'name', 'subnets': 'subnets', 'error': 'error'}
+ _toSchema = {'error': 'error', 'name': 'name', 'subnets': 'subnets'}
+ _toPy = {'error': 'error', 'name': 'name', 'subnets': 'subnets'}
def __init__(self, error=None, name=None, subnets=None):
'''
error : Error
class StatusHistoryPruneArgs(Type):
- _toSchema = {'max_history_time': 'max-history-time', 'max_history_mb': 'max-history-mb'}
+ _toSchema = {'max_history_mb': 'max-history-mb', 'max_history_time': 'max-history-time'}
_toPy = {'max-history-mb': 'max_history_mb', 'max-history-time': 'max_history_time'}
def __init__(self, max_history_mb=None, max_history_time=None):
'''
class FilesystemAttachmentInfo(Type):
- _toSchema = {'read_only': 'read-only', 'mount_point': 'mount-point'}
- _toPy = {'read-only': 'read_only', 'mount-point': 'mount_point'}
+ _toSchema = {'mount_point': 'mount-point', 'read_only': 'read-only'}
+ _toPy = {'mount-point': 'mount_point', 'read-only': 'read_only'}
def __init__(self, mount_point=None, read_only=None):
'''
mount_point : str
class FilesystemDetails(Type):
- _toSchema = {'info': 'info', 'machine_attachments': 'machine-attachments', 'status': 'status', 'storage': 'storage', 'filesystem_tag': 'filesystem-tag', 'volume_tag': 'volume-tag'}
- _toPy = {'info': 'info', 'status': 'status', 'storage': 'storage', 'machine-attachments': 'machine_attachments', 'volume-tag': 'volume_tag', 'filesystem-tag': 'filesystem_tag'}
+ _toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'machine_attachments': 'machine-attachments', 'status': 'status', 'storage': 'storage', 'volume_tag': 'volume-tag'}
+ _toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'machine-attachments': 'machine_attachments', 'status': 'status', 'storage': 'storage', 'volume-tag': 'volume_tag'}
def __init__(self, filesystem_tag=None, info=None, machine_attachments=None, status=None, storage=None, volume_tag=None):
'''
filesystem_tag : str
class FilesystemDetailsListResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class FilesystemInfo(Type):
- _toSchema = {'size': 'size', 'filesystem_id': 'filesystem-id'}
- _toPy = {'size': 'size', 'filesystem-id': 'filesystem_id'}
+ _toSchema = {'filesystem_id': 'filesystem-id', 'size': 'size'}
+ _toPy = {'filesystem-id': 'filesystem_id', 'size': 'size'}
def __init__(self, filesystem_id=None, size=None):
'''
filesystem_id : str
class StorageAddParams(Type):
- _toSchema = {'name': 'name', 'unit': 'unit', 'storage': 'storage'}
- _toPy = {'name': 'name', 'unit': 'unit', 'storage': 'storage'}
+ _toSchema = {'name': 'name', 'storage': 'storage', 'unit': 'unit'}
+ _toPy = {'name': 'name', 'storage': 'storage', 'unit': 'unit'}
def __init__(self, name=None, storage=None, unit=None):
'''
name : str
class StorageAttachmentDetails(Type):
- _toSchema = {'unit_tag': 'unit-tag', 'machine_tag': 'machine-tag', 'storage_tag': 'storage-tag', 'location': 'location'}
- _toPy = {'unit-tag': 'unit_tag', 'machine-tag': 'machine_tag', 'storage-tag': 'storage_tag', 'location': 'location'}
+ _toSchema = {'location': 'location', 'machine_tag': 'machine-tag', 'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
+ _toPy = {'location': 'location', 'machine-tag': 'machine_tag', 'storage-tag': 'storage_tag', 'unit-tag': 'unit_tag'}
def __init__(self, location=None, machine_tag=None, storage_tag=None, unit_tag=None):
'''
location : str
self.unit_tag = unit_tag
-class StorageConstraints(Type):
- _toSchema = {'size': 'size', 'pool': 'pool', 'count': 'count'}
- _toPy = {'size': 'size', 'pool': 'pool', 'count': 'count'}
- def __init__(self, count=None, pool=None, size=None):
- '''
- count : int
- pool : str
- size : int
- '''
- self.count = count
- self.pool = pool
- self.size = size
-
-
class StorageDetails(Type):
- _toSchema = {'kind': 'kind', 'owner_tag': 'owner-tag', 'status': 'status', 'persistent': 'persistent', 'storage_tag': 'storage-tag', 'attachments': 'attachments'}
- _toPy = {'kind': 'kind', 'storage-tag': 'storage_tag', 'status': 'status', 'owner-tag': 'owner_tag', 'persistent': 'persistent', 'attachments': 'attachments'}
+ _toSchema = {'attachments': 'attachments', 'kind': 'kind', 'owner_tag': 'owner-tag', 'persistent': 'persistent', 'status': 'status', 'storage_tag': 'storage-tag'}
+ _toPy = {'attachments': 'attachments', 'kind': 'kind', 'owner-tag': 'owner_tag', 'persistent': 'persistent', 'status': 'status', 'storage-tag': 'storage_tag'}
def __init__(self, attachments=None, kind=None, owner_tag=None, persistent=None, status=None, storage_tag=None):
'''
attachments : typing.Mapping<~KT, +VT_co>[str, ~StorageAttachmentDetails]<~StorageAttachmentDetails>
class StorageDetailsListResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class StorageDetailsResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class StoragePool(Type):
- _toSchema = {'name': 'name', 'attrs': 'attrs', 'provider': 'provider'}
- _toPy = {'name': 'name', 'attrs': 'attrs', 'provider': 'provider'}
+ _toSchema = {'attrs': 'attrs', 'name': 'name', 'provider': 'provider'}
+ _toPy = {'attrs': 'attrs', 'name': 'name', 'provider': 'provider'}
def __init__(self, attrs=None, name=None, provider=None):
'''
attrs : typing.Mapping<~KT, +VT_co>[str, typing.Any]
class StoragePoolsResult(Type):
- _toSchema = {'storage_pools': 'storage-pools', 'error': 'error'}
- _toPy = {'storage-pools': 'storage_pools', 'error': 'error'}
+ _toSchema = {'error': 'error', 'storage_pools': 'storage-pools'}
+ _toPy = {'error': 'error', 'storage-pools': 'storage_pools'}
def __init__(self, error=None, storage_pools=None):
'''
error : Error
class VolumeDetails(Type):
- _toSchema = {'info': 'info', 'machine_attachments': 'machine-attachments', 'volume_tag': 'volume-tag', 'status': 'status', 'storage': 'storage'}
- _toPy = {'info': 'info', 'status': 'status', 'machine-attachments': 'machine_attachments', 'volume-tag': 'volume_tag', 'storage': 'storage'}
+ _toSchema = {'info': 'info', 'machine_attachments': 'machine-attachments', 'status': 'status', 'storage': 'storage', 'volume_tag': 'volume-tag'}
+ _toPy = {'info': 'info', 'machine-attachments': 'machine_attachments', 'status': 'status', 'storage': 'storage', 'volume-tag': 'volume_tag'}
def __init__(self, info=None, machine_attachments=None, status=None, storage=None, volume_tag=None):
'''
info : VolumeInfo
class VolumeDetailsListResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class BlockDeviceResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class Filesystem(Type):
- _toSchema = {'info': 'info', 'filesystem_tag': 'filesystem-tag', 'volume_tag': 'volume-tag'}
- _toPy = {'info': 'info', 'volume-tag': 'volume_tag', 'filesystem-tag': 'filesystem_tag'}
+ _toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'volume_tag': 'volume-tag'}
+ _toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'volume-tag': 'volume_tag'}
def __init__(self, filesystem_tag=None, info=None, volume_tag=None):
'''
filesystem_tag : str
class FilesystemAttachment(Type):
- _toSchema = {'info': 'info', 'filesystem_tag': 'filesystem-tag', 'machine_tag': 'machine-tag'}
- _toPy = {'info': 'info', 'machine-tag': 'machine_tag', 'filesystem-tag': 'filesystem_tag'}
+ _toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'machine_tag': 'machine-tag'}
+ _toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'machine-tag': 'machine_tag'}
def __init__(self, filesystem_tag=None, info=None, machine_tag=None):
'''
filesystem_tag : str
class FilesystemAttachmentParams(Type):
- _toSchema = {'read_only': 'read-only', 'machine_tag': 'machine-tag', 'instance_id': 'instance-id', 'filesystem_id': 'filesystem-id', 'filesystem_tag': 'filesystem-tag', 'mount_point': 'mount-point', 'provider': 'provider'}
- _toPy = {'instance-id': 'instance_id', 'provider': 'provider', 'read-only': 'read_only', 'machine-tag': 'machine_tag', 'filesystem-id': 'filesystem_id', 'mount-point': 'mount_point', 'filesystem-tag': 'filesystem_tag'}
+ _toSchema = {'filesystem_id': 'filesystem-id', 'filesystem_tag': 'filesystem-tag', 'instance_id': 'instance-id', 'machine_tag': 'machine-tag', 'mount_point': 'mount-point', 'provider': 'provider', 'read_only': 'read-only'}
+ _toPy = {'filesystem-id': 'filesystem_id', 'filesystem-tag': 'filesystem_tag', 'instance-id': 'instance_id', 'machine-tag': 'machine_tag', 'mount-point': 'mount_point', 'provider': 'provider', 'read-only': 'read_only'}
def __init__(self, filesystem_id=None, filesystem_tag=None, instance_id=None, machine_tag=None, mount_point=None, provider=None, read_only=None):
'''
filesystem_id : str
class FilesystemAttachmentParamsResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class FilesystemAttachmentResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class FilesystemParams(Type):
- _toSchema = {'attachment': 'attachment', 'size': 'size', 'tags': 'tags', 'attributes': 'attributes', 'filesystem_tag': 'filesystem-tag', 'volume_tag': 'volume-tag', 'provider': 'provider'}
- _toPy = {'attachment': 'attachment', 'size': 'size', 'tags': 'tags', 'attributes': 'attributes', 'provider': 'provider', 'volume-tag': 'volume_tag', 'filesystem-tag': 'filesystem_tag'}
+ _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'filesystem_tag': 'filesystem-tag', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume_tag': 'volume-tag'}
+ _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'filesystem-tag': 'filesystem_tag', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume-tag': 'volume_tag'}
def __init__(self, attachment=None, attributes=None, filesystem_tag=None, provider=None, size=None, tags=None, volume_tag=None):
'''
attachment : FilesystemAttachmentParams
class FilesystemParamsResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class FilesystemResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class VolumeAttachmentParamsResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class VolumeAttachmentResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class VolumeParamsResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class VolumeResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class SpaceResult(Type):
- _toSchema = {'tag': 'tag', 'error': 'error'}
- _toPy = {'tag': 'tag', 'error': 'error'}
+ _toSchema = {'error': 'error', 'tag': 'tag'}
+ _toPy = {'error': 'error', 'tag': 'tag'}
def __init__(self, error=None, tag=None):
'''
error : Error
class ZoneResult(Type):
- _toSchema = {'name': 'name', 'available': 'available', 'error': 'error'}
- _toPy = {'name': 'name', 'available': 'available', 'error': 'error'}
+ _toSchema = {'available': 'available', 'error': 'error', 'name': 'name'}
+ _toPy = {'available': 'available', 'error': 'error', 'name': 'name'}
def __init__(self, available=None, error=None, name=None):
'''
available : bool
class UndertakerModelInfo(Type):
- _toSchema = {'is_system': 'is-system', 'life': 'life', 'uuid': 'uuid', 'global_name': 'global-name', 'name': 'name'}
- _toPy = {'global-name': 'global_name', 'is-system': 'is_system', 'uuid': 'uuid', 'life': 'life', 'name': 'name'}
+ _toSchema = {'global_name': 'global-name', 'is_system': 'is-system', 'life': 'life', 'name': 'name', 'uuid': 'uuid'}
+ _toPy = {'global-name': 'global_name', 'is-system': 'is_system', 'life': 'life', 'name': 'name', 'uuid': 'uuid'}
def __init__(self, global_name=None, is_system=None, life=None, name=None, uuid=None):
'''
global_name : str
class UndertakerModelInfoResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class ApplicationStatusResult(Type):
- _toSchema = {'application': 'application', 'units': 'units', 'error': 'error'}
- _toPy = {'application': 'application', 'units': 'units', 'error': 'error'}
+ _toSchema = {'application': 'application', 'error': 'error', 'units': 'units'}
+ _toPy = {'application': 'application', 'error': 'error', 'units': 'units'}
def __init__(self, application=None, error=None, units=None):
'''
application : StatusResult
class ConfigSettingsResult(Type):
- _toSchema = {'settings': 'settings', 'error': 'error'}
- _toPy = {'settings': 'settings', 'error': 'error'}
+ _toSchema = {'error': 'error', 'settings': 'settings'}
+ _toPy = {'error': 'error', 'settings': 'settings'}
def __init__(self, error=None, settings=None):
'''
error : Error
class Endpoint(Type):
- _toSchema = {'relation': 'relation', 'application_name': 'application-name'}
- _toPy = {'relation': 'relation', 'application-name': 'application_name'}
+ _toSchema = {'application_name': 'application-name', 'relation': 'relation'}
+ _toPy = {'application-name': 'application_name', 'relation': 'relation'}
def __init__(self, application_name=None, relation=None):
'''
application_name : str
class EntityCharmURL(Type):
- _toSchema = {'tag': 'tag', 'charm_url': 'charm-url'}
+ _toSchema = {'charm_url': 'charm-url', 'tag': 'tag'}
_toPy = {'charm-url': 'charm_url', 'tag': 'tag'}
def __init__(self, charm_url=None, tag=None):
'''
class EntityPortRange(Type):
- _toSchema = {'from_port': 'from-port', 'to_port': 'to-port', 'tag': 'tag', 'protocol': 'protocol'}
- _toPy = {'from-port': 'from_port', 'tag': 'tag', 'protocol': 'protocol', 'to-port': 'to_port'}
+ _toSchema = {'from_port': 'from-port', 'protocol': 'protocol', 'tag': 'tag', 'to_port': 'to-port'}
+ _toPy = {'from-port': 'from_port', 'protocol': 'protocol', 'tag': 'tag', 'to-port': 'to_port'}
def __init__(self, from_port=None, protocol=None, tag=None, to_port=None):
'''
from_port : int
class GetLeadershipSettingsResult(Type):
- _toSchema = {'settings': 'settings', 'error': 'error'}
- _toPy = {'settings': 'settings', 'error': 'error'}
+ _toSchema = {'error': 'error', 'settings': 'settings'}
+ _toPy = {'error': 'error', 'settings': 'settings'}
def __init__(self, error=None, settings=None):
'''
error : Error
class IntResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class MergeLeadershipSettingsParam(Type):
- _toSchema = {'settings': 'settings', 'application_tag': 'application-tag'}
+ _toSchema = {'application_tag': 'application-tag', 'settings': 'settings'}
_toPy = {'application-tag': 'application_tag', 'settings': 'settings'}
def __init__(self, application_tag=None, settings=None):
'''
class ModelResult(Type):
- _toSchema = {'name': 'name', 'uuid': 'uuid', 'error': 'error'}
- _toPy = {'name': 'name', 'uuid': 'uuid', 'error': 'error'}
+ _toSchema = {'error': 'error', 'name': 'name', 'uuid': 'uuid'}
+ _toPy = {'error': 'error', 'name': 'name', 'uuid': 'uuid'}
def __init__(self, error=None, name=None, uuid=None):
'''
error : Error
class RelationResult(Type):
- _toSchema = {'life': 'life', 'endpoint': 'endpoint', 'id_': 'id', 'key': 'key', 'error': 'error'}
- _toPy = {'life': 'life', 'endpoint': 'endpoint', 'id': 'id_', 'key': 'key', 'error': 'error'}
+ _toSchema = {'endpoint': 'endpoint', 'error': 'error', 'id_': 'id', 'key': 'key', 'life': 'life'}
+ _toPy = {'endpoint': 'endpoint', 'error': 'error', 'id': 'id_', 'key': 'key', 'life': 'life'}
def __init__(self, endpoint=None, error=None, id_=None, key=None, life=None):
'''
endpoint : Endpoint
class RelationUnitPair(Type):
- _toSchema = {'relation': 'relation', 'local_unit': 'local-unit', 'remote_unit': 'remote-unit'}
- _toPy = {'remote-unit': 'remote_unit', 'local-unit': 'local_unit', 'relation': 'relation'}
+ _toSchema = {'local_unit': 'local-unit', 'relation': 'relation', 'remote_unit': 'remote-unit'}
+ _toPy = {'local-unit': 'local_unit', 'relation': 'relation', 'remote-unit': 'remote_unit'}
def __init__(self, local_unit=None, relation=None, remote_unit=None):
'''
local_unit : str
class ResolvedModeResult(Type):
- _toSchema = {'mode': 'mode', 'error': 'error'}
- _toPy = {'mode': 'mode', 'error': 'error'}
+ _toSchema = {'error': 'error', 'mode': 'mode'}
+ _toPy = {'error': 'error', 'mode': 'mode'}
def __init__(self, error=None, mode=None):
'''
error : Error
class SettingsResult(Type):
- _toSchema = {'settings': 'settings', 'error': 'error'}
- _toPy = {'settings': 'settings', 'error': 'error'}
+ _toSchema = {'error': 'error', 'settings': 'settings'}
+ _toPy = {'error': 'error', 'settings': 'settings'}
def __init__(self, error=None, settings=None):
'''
error : Error
class StorageAttachment(Type):
- _toSchema = {'kind': 'kind', 'owner_tag': 'owner-tag', 'location': 'location', 'life': 'life', 'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
- _toPy = {'kind': 'kind', 'storage-tag': 'storage_tag', 'location': 'location', 'life': 'life', 'owner-tag': 'owner_tag', 'unit-tag': 'unit_tag'}
+ _toSchema = {'kind': 'kind', 'life': 'life', 'location': 'location', 'owner_tag': 'owner-tag', 'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
+ _toPy = {'kind': 'kind', 'life': 'life', 'location': 'location', 'owner-tag': 'owner_tag', 'storage-tag': 'storage_tag', 'unit-tag': 'unit_tag'}
def __init__(self, kind=None, life=None, location=None, owner_tag=None, storage_tag=None, unit_tag=None):
'''
kind : int
class StorageAttachmentId(Type):
_toSchema = {'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
- _toPy = {'unit-tag': 'unit_tag', 'storage-tag': 'storage_tag'}
+ _toPy = {'storage-tag': 'storage_tag', 'unit-tag': 'unit_tag'}
def __init__(self, storage_tag=None, unit_tag=None):
'''
storage_tag : str
class StorageAttachmentIdsResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class StorageAttachmentResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
class StringBoolResult(Type):
- _toSchema = {'result': 'result', 'ok': 'ok', 'error': 'error'}
- _toPy = {'result': 'result', 'ok': 'ok', 'error': 'error'}
+ _toSchema = {'error': 'error', 'ok': 'ok', 'result': 'result'}
+ _toPy = {'error': 'error', 'ok': 'ok', 'result': 'result'}
def __init__(self, error=None, ok=None, result=None):
'''
error : Error
class UnitNetworkConfigResult(Type):
- _toSchema = {'info': 'info', 'error': 'error'}
- _toPy = {'info': 'info', 'error': 'error'}
+ _toSchema = {'error': 'error', 'info': 'info'}
+ _toPy = {'error': 'error', 'info': 'info'}
def __init__(self, error=None, info=None):
'''
error : Error
self.tools = Version.from_json(tools) if tools else None
+class Version(Type):
+ _toSchema = {'version': 'version'}
+ _toPy = {'version': 'version'}
+ def __init__(self, version=None):
+ '''
+ version : Binary
+ '''
+ self.version = Binary.from_json(version) if version else None
+
+
class VersionResult(Type):
- _toSchema = {'version': 'version', 'error': 'error'}
- _toPy = {'version': 'version', 'error': 'error'}
+ _toSchema = {'error': 'error', 'version': 'version'}
+ _toPy = {'error': 'error', 'version': 'version'}
def __init__(self, error=None, version=None):
'''
error : Error
class AddUser(Type):
- _toSchema = {'display_name': 'display-name', 'username': 'username', 'password': 'password'}
+ _toSchema = {'display_name': 'display-name', 'password': 'password', 'username': 'username'}
_toPy = {'display-name': 'display_name', 'password': 'password', 'username': 'username'}
def __init__(self, display_name=None, password=None, username=None):
'''
class AddUserResult(Type):
- _toSchema = {'secret_key': 'secret-key', 'tag': 'tag', 'error': 'error'}
- _toPy = {'tag': 'tag', 'secret-key': 'secret_key', 'error': 'error'}
+ _toSchema = {'error': 'error', 'secret_key': 'secret-key', 'tag': 'tag'}
+ _toPy = {'error': 'error', 'secret-key': 'secret_key', 'tag': 'tag'}
def __init__(self, error=None, secret_key=None, tag=None):
'''
error : Error
self.users = [AddUser.from_json(o) for o in users or []]
-class MacaroonResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
- def __init__(self, error=None, result=None):
- '''
- error : Error
- result : Macaroon
- '''
- self.error = Error.from_json(error) if error else None
- self.result = Macaroon.from_json(result) if result else None
-
-
-class MacaroonResults(Type):
- _toSchema = {'results': 'results'}
- _toPy = {'results': 'results'}
- def __init__(self, results=None):
- '''
- results : typing.Sequence<+T_co>[~MacaroonResult]<~MacaroonResult>
- '''
- self.results = [MacaroonResult.from_json(o) for o in results or []]
-
-
class UserInfo(Type):
- _toSchema = {'display_name': 'display-name', 'username': 'username', 'last_connection': 'last-connection', 'disabled': 'disabled', 'access': 'access', 'created_by': 'created-by', 'date_created': 'date-created'}
- _toPy = {'last-connection': 'last_connection', 'username': 'username', 'disabled': 'disabled', 'date-created': 'date_created', 'created-by': 'created_by', 'access': 'access', 'display-name': 'display_name'}
+ _toSchema = {'access': 'access', 'created_by': 'created-by', 'date_created': 'date-created', 'disabled': 'disabled', 'display_name': 'display-name', 'last_connection': 'last-connection', 'username': 'username'}
+ _toPy = {'access': 'access', 'created-by': 'created_by', 'date-created': 'date_created', 'disabled': 'disabled', 'display-name': 'display_name', 'last-connection': 'last_connection', 'username': 'username'}
def __init__(self, access=None, created_by=None, date_created=None, disabled=None, display_name=None, last_connection=None, username=None):
'''
access : str
class UserInfoRequest(Type):
- _toSchema = {'include_disabled': 'include-disabled', 'entities': 'entities'}
+ _toSchema = {'entities': 'entities', 'include_disabled': 'include-disabled'}
_toPy = {'entities': 'entities', 'include-disabled': 'include_disabled'}
def __init__(self, entities=None, include_disabled=None):
'''
class UserInfoResult(Type):
- _toSchema = {'result': 'result', 'error': 'error'}
- _toPy = {'result': 'result', 'error': 'error'}
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None):
'''
error : Error
Returns -> typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='Actions', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Action', request='Actions', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ApplicationCharmActionsResult]<~ApplicationCharmActionsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='ApplicationsCharmsActions', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Action', request='ApplicationsCharmsActions', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='Cancel', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Action', request='Cancel', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='Enqueue', version=2, params=params)
- params['actions'] = actions
+ _params = dict()
+ msg = dict(type='Action', request='Enqueue', version=2, params=_params)
+ _params['actions'] = actions
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~Entity]<~Entity>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='FindActionTagsByPrefix', version=2, params=params)
- params['prefixes'] = prefixes
+ _params = dict()
+ msg = dict(type='Action', request='FindActionTagsByPrefix', version=2, params=_params)
+ _params['prefixes'] = prefixes
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionsByName]<~ActionsByName>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='FindActionsByNames', version=2, params=params)
- params['names'] = names
+ _params = dict()
+ msg = dict(type='Action', request='FindActionsByNames', version=2, params=_params)
+ _params['names'] = names
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionsByReceiver]<~ActionsByReceiver>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='ListAll', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Action', request='ListAll', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionsByReceiver]<~ActionsByReceiver>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='ListCompleted', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Action', request='ListCompleted', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionsByReceiver]<~ActionsByReceiver>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='ListPending', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Action', request='ListPending', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionsByReceiver]<~ActionsByReceiver>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='ListRunning', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Action', request='ListRunning', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='Run', version=2, params=params)
- params['applications'] = applications
- params['commands'] = commands
- params['machines'] = machines
- params['timeout'] = timeout
- params['units'] = units
+ _params = dict()
+ msg = dict(type='Action', request='Run', version=2, params=_params)
+ _params['applications'] = applications
+ _params['commands'] = commands
+ _params['machines'] = machines
+ _params['timeout'] = timeout
+ _params['units'] = units
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Action', request='RunOnAllMachines', version=2, params=params)
- params['applications'] = applications
- params['commands'] = commands
- params['machines'] = machines
- params['timeout'] = timeout
- params['units'] = units
+ _params = dict()
+ msg = dict(type='Action', request='RunOnAllMachines', version=2, params=_params)
+ _params['applications'] = applications
+ _params['commands'] = commands
+ _params['machines'] = machines
+ _params['timeout'] = timeout
+ _params['units'] = units
reply = await self.rpc(msg)
return reply
'type': 'object'}},
'required': ['config'],
'type': 'object'},
+ 'ModelTag': {'additionalProperties': False, 'type': 'object'},
'NotifyWatchResult': {'additionalProperties': False,
'properties': {'NotifyWatcherId': {'type': 'string'},
'error': {'$ref': '#/definitions/Error'}},
'required': ['NotifyWatcherId'],
'type': 'object'},
+ 'NotifyWatchResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/NotifyWatchResult'},
+ 'type': 'array'}},
+ 'required': ['results'],
+ 'type': 'object'},
'StateServingInfo': {'additionalProperties': False,
'properties': {'api-port': {'type': 'integer'},
'ca-private-key': {'type': 'string'},
'type': 'object'},
'ControllerConfig': {'properties': {'Result': {'$ref': '#/definitions/ControllerConfigResult'}},
'type': 'object'},
+ 'GetCloudSpec': {'properties': {'Params': {'$ref': '#/definitions/ModelTag'},
+ 'Result': {'$ref': '#/definitions/CloudSpecResult'}},
+ 'type': 'object'},
'GetEntities': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
'Result': {'$ref': '#/definitions/AgentGetEntitiesResults'}},
'type': 'object'},
'type': 'object'},
'StateServingInfo': {'properties': {'Result': {'$ref': '#/definitions/StateServingInfo'}},
'type': 'object'},
+ 'WatchCredentials': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/NotifyWatchResults'}},
+ 'type': 'object'},
'WatchForModelConfigChanges': {'properties': {'Result': {'$ref': '#/definitions/NotifyWatchResult'}},
'type': 'object'}},
'type': 'object'}
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Agent', request='ClearReboot', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Agent', request='ClearReboot', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~CloudSpecResult]<~CloudSpecResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Agent', request='CloudSpec', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Agent', request='CloudSpec', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Agent', request='ControllerConfig', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Agent', request='ControllerConfig', version=2, params=_params)
+
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(CloudSpecResult)
+ async def GetCloudSpec(self):
+ '''
+
+ Returns -> typing.Union[_ForwardRef('Error'), _ForwardRef('CloudSpec')]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Agent', request='GetCloudSpec', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~AgentGetEntitiesResult]<~AgentGetEntitiesResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Agent', request='GetEntities', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Agent', request='GetEntities', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> bool
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Agent', request='IsMaster', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Agent', request='IsMaster', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Agent', request='ModelConfig', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Agent', request='ModelConfig', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Agent', request='SetPasswords', version=2, params=params)
- params['changes'] = changes
+ _params = dict()
+ msg = dict(type='Agent', request='SetPasswords', version=2, params=_params)
+ _params['changes'] = changes
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[int, str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Agent', request='StateServingInfo', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Agent', request='StateServingInfo', version=2, params=_params)
+
+ reply = await self.rpc(msg)
+ return reply
+
+
+ @ReturnMapping(NotifyWatchResults)
+ async def WatchCredentials(self, entities):
+ '''
+ entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+ Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Agent', request='WatchCredentials', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Agent', request='WatchForModelConfigChanges', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Agent', request='WatchForModelConfigChanges', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='AgentTools', request='UpdateToolsAvailable', version=1, params=params)
+ _params = dict()
+ msg = dict(type='AgentTools', request='UpdateToolsAvailable', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~Delta]<~Delta>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='AllModelWatcher', request='Next', version=2, params=params)
+ _params = dict()
+ msg = dict(type='AllModelWatcher', request='Next', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='AllModelWatcher', request='Stop', version=2, params=params)
+ _params = dict()
+ msg = dict(type='AllModelWatcher', request='Stop', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~Delta]<~Delta>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='AllWatcher', request='Next', version=1, params=params)
+ _params = dict()
+ msg = dict(type='AllWatcher', request='Next', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='AllWatcher', request='Stop', version=1, params=params)
+ _params = dict()
+ msg = dict(type='AllWatcher', request='Stop', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~AnnotationsGetResult]<~AnnotationsGetResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Annotations', request='Get', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Annotations', request='Get', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Annotations', request='Set', version=2, params=params)
- params['annotations'] = annotations
+ _params = dict()
+ msg = dict(type='Annotations', request='Set', version=2, params=_params)
+ _params['annotations'] = annotations
reply = await self.rpc(msg)
return reply
class ApplicationFacade(Type):
name = 'Application'
- version = 1
+ version = 3
schema = {'definitions': {'AddApplicationUnits': {'additionalProperties': False,
'properties': {'application': {'type': 'string'},
'num-units': {'type': 'integer'},
'properties': {'application': {'type': 'string'},
'channel': {'type': 'string'},
'charm-url': {'type': 'string'},
+ 'config-settings': {'patternProperties': {'.*': {'type': 'string'}},
+ 'type': 'object'},
+ 'config-settings-yaml': {'type': 'string'},
'force-series': {'type': 'boolean'},
'force-units': {'type': 'boolean'},
'resource-ids': {'patternProperties': {'.*': {'type': 'string'}},
- 'type': 'object'}},
+ 'type': 'object'},
+ 'storage-constraints': {'patternProperties': {'.*': {'$ref': '#/definitions/StorageConstraints'}},
+ 'type': 'object'}},
'required': ['application',
'charm-url',
'channel',
'constraints': {'$ref': '#/definitions/Value'}},
'required': ['application', 'constraints'],
'type': 'object'},
+ 'StorageConstraints': {'additionalProperties': False,
+ 'properties': {'count': {'type': 'integer'},
+ 'pool': {'type': 'string'},
+ 'size': {'type': 'integer'}},
+ 'type': 'object'},
'StringResult': {'additionalProperties': False,
'properties': {'error': {'$ref': '#/definitions/Error'},
'result': {'type': 'string'}},
'Value': {'additionalProperties': False,
'properties': {'arch': {'type': 'string'},
'container': {'type': 'string'},
- 'cpu-cores': {'type': 'integer'},
+ 'cores': {'type': 'integer'},
'cpu-power': {'type': 'integer'},
'instance-type': {'type': 'string'},
'mem': {'type': 'integer'},
Returns -> typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='AddRelation', version=1, params=params)
- params['endpoints'] = endpoints
+ _params = dict()
+ msg = dict(type='Application', request='AddRelation', version=3, params=_params)
+ _params['endpoints'] = endpoints
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='AddUnits', version=1, params=params)
- params['application'] = application
- params['num-units'] = num_units
- params['placement'] = placement
+ _params = dict()
+ msg = dict(type='Application', request='AddUnits', version=3, params=_params)
+ _params['application'] = application
+ _params['num-units'] = num_units
+ _params['placement'] = placement
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='CharmRelations', version=1, params=params)
- params['application'] = application
+ _params = dict()
+ msg = dict(type='Application', request='CharmRelations', version=3, params=_params)
+ _params['application'] = application
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='Deploy', version=1, params=params)
- params['applications'] = applications
+ _params = dict()
+ msg = dict(type='Application', request='Deploy', version=3, params=_params)
+ _params['applications'] = applications
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='Destroy', version=1, params=params)
- params['application'] = application
+ _params = dict()
+ msg = dict(type='Application', request='Destroy', version=3, params=_params)
+ _params['application'] = application
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='DestroyRelation', version=1, params=params)
- params['endpoints'] = endpoints
+ _params = dict()
+ msg = dict(type='Application', request='DestroyRelation', version=3, params=_params)
+ _params['endpoints'] = endpoints
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='DestroyUnits', version=1, params=params)
- params['unit-names'] = unit_names
+ _params = dict()
+ msg = dict(type='Application', request='DestroyUnits', version=3, params=_params)
+ _params['unit-names'] = unit_names
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='Expose', version=1, params=params)
- params['application'] = application
+ _params = dict()
+ msg = dict(type='Application', request='Expose', version=3, params=_params)
+ _params['application'] = application
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, typing.Mapping<~KT, +VT_co>[str, typing.Any], _ForwardRef('Value')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='Get', version=1, params=params)
- params['application'] = application
+ _params = dict()
+ msg = dict(type='Application', request='Get', version=3, params=_params)
+ _params['application'] = application
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='GetCharmURL', version=1, params=params)
- params['application'] = application
+ _params = dict()
+ msg = dict(type='Application', request='GetCharmURL', version=3, params=_params)
+ _params['application'] = application
reply = await self.rpc(msg)
return reply
Returns -> Value
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='GetConstraints', version=1, params=params)
- params['application'] = application
+ _params = dict()
+ msg = dict(type='Application', request='GetConstraints', version=3, params=_params)
+ _params['application'] = application
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='Set', version=1, params=params)
- params['application'] = application
- params['options'] = options
+ _params = dict()
+ msg = dict(type='Application', request='Set', version=3, params=_params)
+ _params['application'] = application
+ _params['options'] = options
reply = await self.rpc(msg)
return reply
@ReturnMapping(None)
- async def SetCharm(self, application, channel, charm_url, force_series, force_units, resource_ids):
+ async def SetCharm(self, application, channel, charm_url, config_settings, config_settings_yaml, force_series, force_units, resource_ids, storage_constraints):
'''
application : str
channel : str
charm_url : str
+ config_settings : typing.Mapping<~KT, +VT_co>[str, str]
+ config_settings_yaml : str
force_series : bool
force_units : bool
resource_ids : typing.Mapping<~KT, +VT_co>[str, str]
+ storage_constraints : typing.Mapping<~KT, +VT_co>[str, ~StorageConstraints]<~StorageConstraints>
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='SetCharm', version=1, params=params)
- params['application'] = application
- params['channel'] = channel
- params['charm-url'] = charm_url
- params['force-series'] = force_series
- params['force-units'] = force_units
- params['resource-ids'] = resource_ids
+ _params = dict()
+ msg = dict(type='Application', request='SetCharm', version=3, params=_params)
+ _params['application'] = application
+ _params['channel'] = channel
+ _params['charm-url'] = charm_url
+ _params['config-settings'] = config_settings
+ _params['config-settings-yaml'] = config_settings_yaml
+ _params['force-series'] = force_series
+ _params['force-units'] = force_units
+ _params['resource-ids'] = resource_ids
+ _params['storage-constraints'] = storage_constraints
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='SetConstraints', version=1, params=params)
- params['application'] = application
- params['constraints'] = constraints
+ _params = dict()
+ msg = dict(type='Application', request='SetConstraints', version=3, params=_params)
+ _params['application'] = application
+ _params['constraints'] = constraints
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='SetMetricCredentials', version=1, params=params)
- params['creds'] = creds
+ _params = dict()
+ msg = dict(type='Application', request='SetMetricCredentials', version=3, params=_params)
+ _params['creds'] = creds
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='Unexpose', version=1, params=params)
- params['application'] = application
+ _params = dict()
+ msg = dict(type='Application', request='Unexpose', version=3, params=_params)
+ _params['application'] = application
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='Unset', version=1, params=params)
- params['application'] = application
- params['options'] = options
+ _params = dict()
+ msg = dict(type='Application', request='Unset', version=3, params=_params)
+ _params['application'] = application
+ _params['options'] = options
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Application', request='Update', version=1, params=params)
- params['application'] = application
- params['charm-url'] = charm_url
- params['constraints'] = constraints
- params['force-charm-url'] = force_charm_url
- params['force-series'] = force_series
- params['min-units'] = min_units
- params['settings'] = settings
- params['settings-yaml'] = settings_yaml
+ _params = dict()
+ msg = dict(type='Application', request='Update', version=3, params=_params)
+ _params['application'] = application
+ _params['charm-url'] = charm_url
+ _params['constraints'] = constraints
+ _params['force-charm-url'] = force_charm_url
+ _params['force-series'] = force_series
+ _params['min-units'] = min_units
+ _params['settings'] = settings
+ _params['settings-yaml'] = settings_yaml
+ reply = await self.rpc(msg)
+ return reply
+
+
+class ApplicationRelationsWatcherFacade(Type):
+ name = 'ApplicationRelationsWatcher'
+ version = 1
+ schema = {'definitions': {'ApplicationRelationsChange': {'additionalProperties': False,
+ 'properties': {'changed': {'items': {'$ref': '#/definitions/RelationChange'},
+ 'type': 'array'},
+ 'removed': {'items': {'type': 'integer'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'ApplicationRelationsWatchResult': {'additionalProperties': False,
+ 'properties': {'ApplicationRelationsWatcherId': {'type': 'string'},
+ 'changes': {'$ref': '#/definitions/ApplicationRelationsChange'},
+ 'error': {'$ref': '#/definitions/Error'}},
+ 'required': ['ApplicationRelationsWatcherId'],
+ 'type': 'object'},
+ 'Error': {'additionalProperties': False,
+ 'properties': {'code': {'type': 'string'},
+ 'info': {'$ref': '#/definitions/ErrorInfo'},
+ 'message': {'type': 'string'}},
+ 'required': ['message', 'code'],
+ 'type': 'object'},
+ 'ErrorInfo': {'additionalProperties': False,
+ 'properties': {'macaroon': {'$ref': '#/definitions/Macaroon'},
+ 'macaroon-path': {'type': 'string'}},
+ 'type': 'object'},
+ 'Macaroon': {'additionalProperties': False, 'type': 'object'},
+ 'RelationChange': {'additionalProperties': False,
+ 'properties': {'changedunits': {'patternProperties': {'.*': {'$ref': '#/definitions/RelationUnitChange'}},
+ 'type': 'object'},
+ 'departedunits': {'items': {'type': 'string'},
+ 'type': 'array'},
+ 'id': {'type': 'integer'},
+ 'life': {'type': 'string'}},
+ 'required': ['id', 'life'],
+ 'type': 'object'},
+ 'RelationUnitChange': {'additionalProperties': False,
+ 'properties': {'settings': {'patternProperties': {'.*': {'additionalProperties': True,
+ 'type': 'object'}},
+ 'type': 'object'}},
+ 'type': 'object'}},
+ 'properties': {'Next': {'properties': {'Result': {'$ref': '#/definitions/ApplicationRelationsWatchResult'}},
+ 'type': 'object'},
+ 'Stop': {'type': 'object'}},
+ 'type': 'object'}
+
+
+ @ReturnMapping(ApplicationRelationsWatchResult)
+ async def Next(self):
+ '''
+
+ Returns -> typing.Union[str, _ForwardRef('ApplicationRelationsChange'), _ForwardRef('Error')]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='ApplicationRelationsWatcher', request='Next', version=1, params=_params)
+
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(None)
+ async def Stop(self):
+ '''
+
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='ApplicationRelationsWatcher', request='Stop', version=1, params=_params)
+
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ApplicationScaler', request='Rescale', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='ApplicationScaler', request='Rescale', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[typing.Sequence<+T_co>[str], _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ApplicationScaler', request='Watch', version=1, params=params)
+ _params = dict()
+ msg = dict(type='ApplicationScaler', request='Watch', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, int, _ForwardRef('Number')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Backups', request='Create', version=1, params=params)
- params['notes'] = notes
+ _params = dict()
+ msg = dict(type='Backups', request='Create', version=1, params=_params)
+ _params['notes'] = notes
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Backups', request='FinishRestore', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Backups', request='FinishRestore', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, int, _ForwardRef('Number')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Backups', request='Info', version=1, params=params)
- params['id'] = id_
+ _params = dict()
+ msg = dict(type='Backups', request='Info', version=1, params=_params)
+ _params['id'] = id_
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~BackupsMetadataResult]<~BackupsMetadataResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Backups', request='List', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Backups', request='List', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Backups', request='PrepareRestore', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Backups', request='PrepareRestore', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Backups', request='Remove', version=1, params=params)
- params['id'] = id_
+ _params = dict()
+ msg = dict(type='Backups', request='Remove', version=1, params=_params)
+ _params['id'] = id_
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Backups', request='Restore', version=1, params=params)
- params['backup-id'] = backup_id
+ _params = dict()
+ msg = dict(type='Backups', request='Restore', version=1, params=_params)
+ _params['backup-id'] = backup_id
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~BlockResult]<~BlockResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Block', request='List', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Block', request='List', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> Error
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Block', request='SwitchBlockOff', version=2, params=params)
- params['message'] = message
- params['type'] = type_
+ _params = dict()
+ msg = dict(type='Block', request='SwitchBlockOff', version=2, params=_params)
+ _params['message'] = message
+ _params['type'] = type_
reply = await self.rpc(msg)
return reply
Returns -> Error
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Block', request='SwitchBlockOn', version=2, params=params)
- params['message'] = message
- params['type'] = type_
+ _params = dict()
+ msg = dict(type='Block', request='SwitchBlockOn', version=2, params=_params)
+ _params['message'] = message
+ _params['type'] = type_
+ reply = await self.rpc(msg)
+ return reply
+
+
+class BundleFacade(Type):
+ name = 'Bundle'
+ version = 1
+ schema = {'definitions': {'BundleChange': {'additionalProperties': False,
+ 'properties': {'args': {'items': {'additionalProperties': True,
+ 'type': 'object'},
+ 'type': 'array'},
+ 'id': {'type': 'string'},
+ 'method': {'type': 'string'},
+ 'requires': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'required': ['id',
+ 'method',
+ 'args',
+ 'requires'],
+ 'type': 'object'},
+ 'BundleChangesParams': {'additionalProperties': False,
+ 'properties': {'yaml': {'type': 'string'}},
+ 'required': ['yaml'],
+ 'type': 'object'},
+ 'BundleChangesResults': {'additionalProperties': False,
+ 'properties': {'changes': {'items': {'$ref': '#/definitions/BundleChange'},
+ 'type': 'array'},
+ 'errors': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'type': 'object'}},
+ 'properties': {'GetChanges': {'properties': {'Params': {'$ref': '#/definitions/BundleChangesParams'},
+ 'Result': {'$ref': '#/definitions/BundleChangesResults'}},
+ 'type': 'object'}},
+ 'type': 'object'}
+
+
+ @ReturnMapping(BundleChangesResults)
+ async def GetChanges(self, yaml):
+ '''
+ yaml : str
+ Returns -> typing.Sequence<+T_co>[~BundleChange]<~BundleChange>
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Bundle', request='GetChanges', version=1, params=_params)
+ _params['yaml'] = yaml
reply = await self.rpc(msg)
return reply
Returns -> Error
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='CharmRevisionUpdater', request='UpdateLatestRevisions', version=2, params=params)
+ _params = dict()
+ msg = dict(type='CharmRevisionUpdater', request='UpdateLatestRevisions', version=2, params=_params)
reply = await self.rpc(msg)
return reply
'type': 'object'},
'CharmMetrics': {'additionalProperties': False,
'properties': {'metrics': {'patternProperties': {'.*': {'$ref': '#/definitions/CharmMetric'}},
- 'type': 'object'}},
- 'required': ['metrics'],
+ 'type': 'object'},
+ 'plan': {'$ref': '#/definitions/CharmPlan'}},
+ 'required': ['metrics', 'plan'],
'type': 'object'},
'CharmOption': {'additionalProperties': False,
'properties': {'default': {'additionalProperties': True,
'type': {'type': 'string'}},
'required': ['name', 'type'],
'type': 'object'},
+ 'CharmPlan': {'additionalProperties': False,
+ 'properties': {'required': {'type': 'boolean'}},
+ 'required': ['required'],
+ 'type': 'object'},
'CharmRelation': {'additionalProperties': False,
'properties': {'interface': {'type': 'string'},
'limit': {'type': 'integer'},
Returns -> typing.Union[_ForwardRef('CharmActions'), typing.Mapping<~KT, +VT_co>[str, ~CharmOption]<~CharmOption>, _ForwardRef('CharmMeta'), _ForwardRef('CharmMetrics'), int, str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Charms', request='CharmInfo', version=2, params=params)
- params['url'] = url
+ _params = dict()
+ msg = dict(type='Charms', request='CharmInfo', version=2, params=_params)
+ _params['url'] = url
reply = await self.rpc(msg)
return reply
Returns -> bool
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Charms', request='IsMetered', version=2, params=params)
- params['url'] = url
+ _params = dict()
+ msg = dict(type='Charms', request='IsMetered', version=2, params=_params)
+ _params['url'] = url
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Charms', request='List', version=2, params=params)
- params['names'] = names
+ _params = dict()
+ msg = dict(type='Charms', request='List', version=2, params=_params)
+ _params['names'] = names
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Cleaner', request='Cleanup', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Cleaner', request='Cleanup', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Cleaner', request='WatchCleanups', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Cleaner', request='WatchCleanups', version=2, params=_params)
reply = await self.rpc(msg)
return reply
'Series': {'type': 'string'}},
'required': ['Number', 'Series', 'Arch'],
'type': 'object'},
- 'BundleChangesChange': {'additionalProperties': False,
- 'properties': {'args': {'items': {'additionalProperties': True,
- 'type': 'object'},
- 'type': 'array'},
- 'id': {'type': 'string'},
- 'method': {'type': 'string'},
- 'requires': {'items': {'type': 'string'},
- 'type': 'array'}},
- 'required': ['id',
- 'method',
- 'args',
- 'requires'],
+ 'BundleChange': {'additionalProperties': False,
+ 'properties': {'args': {'items': {'additionalProperties': True,
+ 'type': 'object'},
+ 'type': 'array'},
+ 'id': {'type': 'string'},
+ 'method': {'type': 'string'},
+ 'requires': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'required': ['id',
+ 'method',
+ 'args',
+ 'requires'],
+ 'type': 'object'},
+ 'BundleChangesParams': {'additionalProperties': False,
+ 'properties': {'yaml': {'type': 'string'}},
+ 'required': ['yaml'],
'type': 'object'},
+ 'BundleChangesResults': {'additionalProperties': False,
+ 'properties': {'changes': {'items': {'$ref': '#/definitions/BundleChange'},
+ 'type': 'array'},
+ 'errors': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'type': 'object'},
'ConfigValue': {'additionalProperties': False,
'properties': {'source': {'type': 'string'},
'value': {'additionalProperties': True,
'type': 'object'},
'model': {'$ref': '#/definitions/ModelStatusInfo'},
'relations': {'items': {'$ref': '#/definitions/RelationStatus'},
- 'type': 'array'}},
+ 'type': 'array'},
+ 'remote-applications': {'patternProperties': {'.*': {'$ref': '#/definitions/RemoteApplicationStatus'}},
+ 'type': 'object'}},
'required': ['model',
'machines',
'applications',
+ 'remote-applications',
'relations'],
'type': 'object'},
- 'GetBundleChangesParams': {'additionalProperties': False,
- 'properties': {'yaml': {'type': 'string'}},
- 'required': ['yaml'],
- 'type': 'object'},
- 'GetBundleChangesResults': {'additionalProperties': False,
- 'properties': {'changes': {'items': {'$ref': '#/definitions/BundleChangesChange'},
- 'type': 'array'},
- 'errors': {'items': {'type': 'string'},
- 'type': 'array'}},
- 'type': 'object'},
'GetConstraintsResults': {'additionalProperties': False,
'properties': {'constraints': {'$ref': '#/definitions/Value'}},
'required': ['constraints'],
'required': ['Address', 'port'],
'type': 'object'},
'Macaroon': {'additionalProperties': False, 'type': 'object'},
+ 'MachineHardware': {'additionalProperties': False,
+ 'properties': {'arch': {'type': 'string'},
+ 'availability-zone': {'type': 'string'},
+ 'cores': {'type': 'integer'},
+ 'cpu-power': {'type': 'integer'},
+ 'mem': {'type': 'integer'},
+ 'root-disk': {'type': 'integer'},
+ 'tags': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'type': 'object'},
'MachineStatus': {'additionalProperties': False,
'properties': {'agent-status': {'$ref': '#/definitions/DetailedStatus'},
'containers': {'patternProperties': {'.*': {'$ref': '#/definitions/MachineStatus'}},
'id': {'type': 'string'},
'instance-id': {'type': 'string'},
'instance-status': {'$ref': '#/definitions/DetailedStatus'},
+ 'ip-addresses': {'items': {'type': 'string'},
+ 'type': 'array'},
'jobs': {'items': {'type': 'string'},
'type': 'array'},
'series': {'type': 'string'},
'required': ['agent-status',
'instance-status',
'dns-name',
+ 'ip-addresses',
'instance-id',
'series',
'id',
'type': 'object'}},
'required': ['config'],
'type': 'object'},
- 'ModelDefaultValues': {'additionalProperties': False,
- 'properties': {'cloud-region': {'type': 'string'},
- 'cloud-tag': {'type': 'string'},
- 'config': {'patternProperties': {'.*': {'additionalProperties': True,
- 'type': 'object'}},
- 'type': 'object'}},
- 'required': ['config'],
- 'type': 'object'},
- 'ModelDefaults': {'additionalProperties': False,
- 'properties': {'controller': {'additionalProperties': True,
- 'type': 'object'},
- 'default': {'additionalProperties': True,
- 'type': 'object'},
- 'regions': {'items': {'$ref': '#/definitions/RegionDefaults'},
- 'type': 'array'}},
- 'type': 'object'},
- 'ModelDefaultsResult': {'additionalProperties': False,
- 'properties': {'config': {'patternProperties': {'.*': {'$ref': '#/definitions/ModelDefaults'}},
- 'type': 'object'}},
- 'required': ['config'],
- 'type': 'object'},
'ModelInfo': {'additionalProperties': False,
- 'properties': {'cloud': {'type': 'string'},
- 'cloud-credential-tag': {'type': 'string'},
+ 'properties': {'cloud-credential-tag': {'type': 'string'},
'cloud-region': {'type': 'string'},
+ 'cloud-tag': {'type': 'string'},
'controller-uuid': {'type': 'string'},
'default-series': {'type': 'string'},
'life': {'type': 'string'},
+ 'machines': {'items': {'$ref': '#/definitions/ModelMachineInfo'},
+ 'type': 'array'},
'name': {'type': 'string'},
'owner-tag': {'type': 'string'},
'provider-type': {'type': 'string'},
'controller-uuid',
'provider-type',
'default-series',
- 'cloud',
+ 'cloud-tag',
'owner-tag',
'life',
'status',
- 'users'],
+ 'users',
+ 'machines'],
'type': 'object'},
+ 'ModelMachineInfo': {'additionalProperties': False,
+ 'properties': {'hardware': {'$ref': '#/definitions/MachineHardware'},
+ 'has-vote': {'type': 'boolean'},
+ 'id': {'type': 'string'},
+ 'instance-id': {'type': 'string'},
+ 'status': {'type': 'string'},
+ 'wants-vote': {'type': 'boolean'}},
+ 'required': ['id'],
+ 'type': 'object'},
'ModelSet': {'additionalProperties': False,
'properties': {'config': {'patternProperties': {'.*': {'additionalProperties': True,
'type': 'object'}},
'type': 'object'},
'ModelStatusInfo': {'additionalProperties': False,
'properties': {'available-version': {'type': 'string'},
- 'cloud': {'type': 'string'},
+ 'cloud-tag': {'type': 'string'},
'migration': {'type': 'string'},
'name': {'type': 'string'},
'region': {'type': 'string'},
'version': {'type': 'string'}},
'required': ['name',
- 'cloud',
+ 'cloud-tag',
'version',
'available-version'],
- 'type': 'object'},
- 'ModelUnset': {'additionalProperties': False,
- 'properties': {'keys': {'items': {'type': 'string'},
- 'type': 'array'}},
- 'required': ['keys'],
- 'type': 'object'},
- 'ModelUnsetKeys': {'additionalProperties': False,
- 'properties': {'cloud-region': {'type': 'string'},
- 'cloud-tag': {'type': 'string'},
- 'keys': {'items': {'type': 'string'},
- 'type': 'array'}},
- 'required': ['keys'],
- 'type': 'object'},
+ 'type': 'object'},
+ 'ModelUnset': {'additionalProperties': False,
+ 'properties': {'keys': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'required': ['keys'],
+ 'type': 'object'},
'ModelUserInfo': {'additionalProperties': False,
'properties': {'access': {'type': 'string'},
'display-name': {'type': 'string'},
'properties': {'public-address': {'type': 'string'}},
'required': ['public-address'],
'type': 'object'},
- 'RegionDefaults': {'additionalProperties': False,
- 'properties': {'region-name': {'type': 'string'},
- 'value': {'additionalProperties': True,
- 'type': 'object'}},
- 'required': ['region-name', 'value'],
- 'type': 'object'},
'RelationStatus': {'additionalProperties': False,
'properties': {'endpoints': {'items': {'$ref': '#/definitions/EndpointStatus'},
'type': 'array'},
'scope',
'endpoints'],
'type': 'object'},
+ 'RemoteApplicationStatus': {'additionalProperties': False,
+ 'properties': {'application-name': {'type': 'string'},
+ 'application-url': {'type': 'string'},
+ 'endpoints': {'items': {'$ref': '#/definitions/RemoteEndpoint'},
+ 'type': 'array'},
+ 'err': {'additionalProperties': True,
+ 'type': 'object'},
+ 'life': {'type': 'string'},
+ 'relations': {'patternProperties': {'.*': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'status': {'$ref': '#/definitions/DetailedStatus'}},
+ 'required': ['application-url',
+ 'application-name',
+ 'endpoints',
+ 'life',
+ 'relations',
+ 'status'],
+ 'type': 'object'},
+ 'RemoteEndpoint': {'additionalProperties': False,
+ 'properties': {'interface': {'type': 'string'},
+ 'limit': {'type': 'integer'},
+ 'name': {'type': 'string'},
+ 'role': {'type': 'string'},
+ 'scope': {'type': 'string'}},
+ 'required': ['name',
+ 'role',
+ 'interface',
+ 'limit',
+ 'scope'],
+ 'type': 'object'},
'ResolveCharmResult': {'additionalProperties': False,
'properties': {'error': {'type': 'string'},
'url': {'type': 'string'}},
'properties': {'version': {'$ref': '#/definitions/Number'}},
'required': ['version'],
'type': 'object'},
- 'SetModelDefaults': {'additionalProperties': False,
- 'properties': {'config': {'items': {'$ref': '#/definitions/ModelDefaultValues'},
- 'type': 'array'}},
- 'required': ['config'],
- 'type': 'object'},
'StatusHistoryFilter': {'additionalProperties': False,
'properties': {'date': {'format': 'date-time',
'type': 'string'},
'UnitStatus': {'additionalProperties': False,
'properties': {'agent-status': {'$ref': '#/definitions/DetailedStatus'},
'charm': {'type': 'string'},
+ 'leader': {'type': 'boolean'},
'machine': {'type': 'string'},
'opened-ports': {'items': {'type': 'string'},
'type': 'array'},
'charm',
'subordinates'],
'type': 'object'},
- 'UnsetModelDefaults': {'additionalProperties': False,
- 'properties': {'keys': {'items': {'$ref': '#/definitions/ModelUnsetKeys'},
- 'type': 'array'}},
- 'required': ['keys'],
- 'type': 'object'},
'Value': {'additionalProperties': False,
'properties': {'arch': {'type': 'string'},
'container': {'type': 'string'},
- 'cpu-cores': {'type': 'integer'},
+ 'cores': {'type': 'integer'},
'cpu-power': {'type': 'integer'},
'instance-type': {'type': 'string'},
'mem': {'type': 'integer'},
'FullStatus': {'properties': {'Params': {'$ref': '#/definitions/StatusParams'},
'Result': {'$ref': '#/definitions/FullStatus'}},
'type': 'object'},
- 'GetBundleChanges': {'properties': {'Params': {'$ref': '#/definitions/GetBundleChangesParams'},
- 'Result': {'$ref': '#/definitions/GetBundleChangesResults'}},
+ 'GetBundleChanges': {'properties': {'Params': {'$ref': '#/definitions/BundleChangesParams'},
+ 'Result': {'$ref': '#/definitions/BundleChangesResults'}},
'type': 'object'},
'GetModelConstraints': {'properties': {'Result': {'$ref': '#/definitions/GetConstraintsResults'}},
'type': 'object'},
'InjectMachines': {'properties': {'Params': {'$ref': '#/definitions/AddMachines'},
'Result': {'$ref': '#/definitions/AddMachinesResults'}},
'type': 'object'},
- 'ModelDefaults': {'properties': {'Result': {'$ref': '#/definitions/ModelDefaultsResult'}},
- 'type': 'object'},
'ModelGet': {'properties': {'Result': {'$ref': '#/definitions/ModelConfigResults'}},
'type': 'object'},
'ModelInfo': {'properties': {'Result': {'$ref': '#/definitions/ModelInfo'}},
'type': 'object'},
'SetModelConstraints': {'properties': {'Params': {'$ref': '#/definitions/SetConstraints'}},
'type': 'object'},
- 'SetModelDefaults': {'properties': {'Params': {'$ref': '#/definitions/SetModelDefaults'},
- 'Result': {'$ref': '#/definitions/ErrorResults'}},
- 'type': 'object'},
'StatusHistory': {'properties': {'Params': {'$ref': '#/definitions/StatusHistoryRequests'},
'Result': {'$ref': '#/definitions/StatusHistoryResults'}},
'type': 'object'},
- 'UnsetModelDefaults': {'properties': {'Params': {'$ref': '#/definitions/UnsetModelDefaults'},
- 'Result': {'$ref': '#/definitions/ErrorResults'}},
- 'type': 'object'},
'WatchAll': {'properties': {'Result': {'$ref': '#/definitions/AllWatcherId'}},
'type': 'object'}},
'type': 'object'}
Returns -> typing.Sequence<+T_co>[~HostPort]<~HostPort>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='APIHostPorts', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Client', request='APIHostPorts', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='AbortCurrentUpgrade', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Client', request='AbortCurrentUpgrade', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='AddCharm', version=1, params=params)
- params['channel'] = channel
- params['url'] = url
+ _params = dict()
+ msg = dict(type='Client', request='AddCharm', version=1, params=_params)
+ _params['channel'] = channel
+ _params['url'] = url
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='AddCharmWithAuthorization', version=1, params=params)
- params['channel'] = channel
- params['macaroon'] = macaroon
- params['url'] = url
+ _params = dict()
+ msg = dict(type='Client', request='AddCharmWithAuthorization', version=1, params=_params)
+ _params['channel'] = channel
+ _params['macaroon'] = macaroon
+ _params['url'] = url
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~AddMachinesResult]<~AddMachinesResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='AddMachines', version=1, params=params)
- params['params'] = params
+ _params = dict()
+ msg = dict(type='Client', request='AddMachines', version=1, params=_params)
+ _params['params'] = params
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~AddMachinesResult]<~AddMachinesResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='AddMachinesV2', version=1, params=params)
- params['params'] = params
+ _params = dict()
+ msg = dict(type='Client', request='AddMachinesV2', version=1, params=_params)
+ _params['params'] = params
reply = await self.rpc(msg)
return reply
Returns -> Number
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='AgentVersion', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Client', request='AgentVersion', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='DestroyMachines', version=1, params=params)
- params['force'] = force
- params['machine-names'] = machine_names
+ _params = dict()
+ msg = dict(type='Client', request='DestroyMachines', version=1, params=_params)
+ _params['force'] = force
+ _params['machine-names'] = machine_names
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence<+T_co>[~Tools]<~Tools>]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='FindTools', version=1, params=params)
- params['arch'] = arch
- params['major'] = major
- params['minor'] = minor
- params['number'] = number
- params['series'] = series
+ _params = dict()
+ msg = dict(type='Client', request='FindTools', version=1, params=_params)
+ _params['arch'] = arch
+ _params['major'] = major
+ _params['minor'] = minor
+ _params['number'] = number
+ _params['series'] = series
reply = await self.rpc(msg)
return reply
async def FullStatus(self, patterns):
'''
patterns : typing.Sequence<+T_co>[str]
- Returns -> typing.Union[typing.Mapping<~KT, +VT_co>[str, ~MachineStatus]<~MachineStatus>, _ForwardRef('ModelStatusInfo'), typing.Sequence<+T_co>[~RelationStatus]<~RelationStatus>]
+ Returns -> typing.Union[_ForwardRef('ModelStatusInfo'), typing.Sequence<+T_co>[~RelationStatus]<~RelationStatus>, typing.Mapping<~KT, +VT_co>[str, ~RemoteApplicationStatus]<~RemoteApplicationStatus>]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='FullStatus', version=1, params=params)
- params['patterns'] = patterns
+ _params = dict()
+ msg = dict(type='Client', request='FullStatus', version=1, params=_params)
+ _params['patterns'] = patterns
reply = await self.rpc(msg)
return reply
- @ReturnMapping(GetBundleChangesResults)
+ @ReturnMapping(BundleChangesResults)
async def GetBundleChanges(self, yaml):
'''
yaml : str
- Returns -> typing.Sequence<+T_co>[~BundleChangesChange]<~BundleChangesChange>
+ Returns -> typing.Sequence<+T_co>[~BundleChange]<~BundleChange>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='GetBundleChanges', version=1, params=params)
- params['yaml'] = yaml
+ _params = dict()
+ msg = dict(type='Client', request='GetBundleChanges', version=1, params=_params)
+ _params['yaml'] = yaml
reply = await self.rpc(msg)
return reply
Returns -> Value
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='GetModelConstraints', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Client', request='GetModelConstraints', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~AddMachinesResult]<~AddMachinesResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='InjectMachines', version=1, params=params)
- params['params'] = params
- reply = await self.rpc(msg)
- return reply
-
-
-
- @ReturnMapping(ModelDefaultsResult)
- async def ModelDefaults(self):
- '''
-
- Returns -> typing.Mapping<~KT, +VT_co>[str, ~ModelDefaults]<~ModelDefaults>
- '''
- # map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='ModelDefaults', version=1, params=params)
-
+ _params = dict()
+ msg = dict(type='Client', request='InjectMachines', version=1, params=_params)
+ _params['params'] = params
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, ~ConfigValue]<~ConfigValue>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='ModelGet', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Client', request='ModelGet', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('EntityStatus'), typing.Sequence<+T_co>[~ModelUserInfo]<~ModelUserInfo>]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='ModelInfo', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Client', request='ModelInfo', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='ModelSet', version=1, params=params)
- params['config'] = config
+ _params = dict()
+ msg = dict(type='Client', request='ModelSet', version=1, params=_params)
+ _params['config'] = config
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='ModelUnset', version=1, params=params)
- params['keys'] = keys
+ _params = dict()
+ msg = dict(type='Client', request='ModelUnset', version=1, params=_params)
+ _params['keys'] = keys
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ModelUserInfoResult]<~ModelUserInfoResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='ModelUserInfo', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Client', request='ModelUserInfo', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> str
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='PrivateAddress', version=1, params=params)
- params['target'] = target
+ _params = dict()
+ msg = dict(type='Client', request='PrivateAddress', version=1, params=_params)
+ _params['target'] = target
reply = await self.rpc(msg)
return reply
Returns -> str
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='ProvisioningScript', version=1, params=params)
- params['data-dir'] = data_dir
- params['disable-package-commands'] = disable_package_commands
- params['machine-id'] = machine_id
- params['nonce'] = nonce
+ _params = dict()
+ msg = dict(type='Client', request='ProvisioningScript', version=1, params=_params)
+ _params['data-dir'] = data_dir
+ _params['disable-package-commands'] = disable_package_commands
+ _params['machine-id'] = machine_id
+ _params['nonce'] = nonce
reply = await self.rpc(msg)
return reply
Returns -> str
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='PublicAddress', version=1, params=params)
- params['target'] = target
+ _params = dict()
+ msg = dict(type='Client', request='PublicAddress', version=1, params=_params)
+ _params['target'] = target
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ResolveCharmResult]<~ResolveCharmResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='ResolveCharms', version=1, params=params)
- params['references'] = references
+ _params = dict()
+ msg = dict(type='Client', request='ResolveCharms', version=1, params=_params)
+ _params['references'] = references
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='Resolved', version=1, params=params)
- params['retry'] = retry
- params['unit-name'] = unit_name
+ _params = dict()
+ msg = dict(type='Client', request='Resolved', version=1, params=_params)
+ _params['retry'] = retry
+ _params['unit-name'] = unit_name
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='RetryProvisioning', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Client', request='RetryProvisioning', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(None)
- async def SetModelAgentVersion(self, build, major, minor, patch, tag):
+ async def SetModelAgentVersion(self, version):
'''
- build : int
- major : int
- minor : int
- patch : int
- tag : str
+ version : Number
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='SetModelAgentVersion', version=1, params=params)
- params['Build'] = build
- params['Major'] = major
- params['Minor'] = minor
- params['Patch'] = patch
- params['Tag'] = tag
+ _params = dict()
+ msg = dict(type='Client', request='SetModelAgentVersion', version=1, params=_params)
+ _params['version'] = version
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='SetModelConstraints', version=1, params=params)
- params['application'] = application
- params['constraints'] = constraints
- reply = await self.rpc(msg)
- return reply
-
-
-
- @ReturnMapping(ErrorResults)
- async def SetModelDefaults(self, config):
- '''
- config : typing.Sequence<+T_co>[~ModelDefaultValues]<~ModelDefaultValues>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
- '''
- # map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='SetModelDefaults', version=1, params=params)
- params['config'] = config
+ _params = dict()
+ msg = dict(type='Client', request='SetModelConstraints', version=1, params=_params)
+ _params['application'] = application
+ _params['constraints'] = constraints
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StatusHistoryResult]<~StatusHistoryResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='StatusHistory', version=1, params=params)
- params['requests'] = requests
- reply = await self.rpc(msg)
- return reply
-
-
-
- @ReturnMapping(ErrorResults)
- async def UnsetModelDefaults(self, keys):
- '''
- keys : typing.Sequence<+T_co>[~ModelUnsetKeys]<~ModelUnsetKeys>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
- '''
- # map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='UnsetModelDefaults', version=1, params=params)
- params['keys'] = keys
+ _params = dict()
+ msg = dict(type='Client', request='StatusHistory', version=1, params=_params)
+ _params['requests'] = requests
reply = await self.rpc(msg)
return reply
Returns -> str
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Client', request='WatchAll', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Client', request='WatchAll', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~CloudResult]<~CloudResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Cloud', request='Cloud', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Cloud', request='Cloud', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, ~Cloud]<~Cloud>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Cloud', request='Clouds', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Cloud', request='Clouds', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~CloudCredentialResult]<~CloudCredentialResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Cloud', request='Credential', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Cloud', request='Credential', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Cloud', request='DefaultCloud', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Cloud', request='DefaultCloud', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Cloud', request='RevokeCredentials', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Cloud', request='RevokeCredentials', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Cloud', request='UpdateCredentials', version=1, params=params)
- params['credentials'] = credentials
+ _params = dict()
+ msg = dict(type='Cloud', request='UpdateCredentials', version=1, params=_params)
+ _params['credentials'] = credentials
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsResult]<~StringsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Cloud', request='UserCredentials', version=1, params=params)
- params['user-clouds'] = user_clouds
+ _params = dict()
+ msg = dict(type='Cloud', request='UserCredentials', version=1, params=_params)
+ _params['user-clouds'] = user_clouds
reply = await self.rpc(msg)
return reply
'type': 'array'}},
'required': ['results'],
'type': 'object'},
+ 'HostedModelConfig': {'additionalProperties': False,
+ 'properties': {'cloud-spec': {'$ref': '#/definitions/CloudSpec'},
+ 'config': {'patternProperties': {'.*': {'additionalProperties': True,
+ 'type': 'object'}},
+ 'type': 'object'},
+ 'error': {'$ref': '#/definitions/Error'},
+ 'name': {'type': 'string'},
+ 'owner': {'type': 'string'}},
+ 'required': ['name', 'owner'],
+ 'type': 'object'},
+ 'HostedModelConfigsResults': {'additionalProperties': False,
+ 'properties': {'models': {'items': {'$ref': '#/definitions/HostedModelConfig'},
+ 'type': 'array'}},
+ 'required': ['models'],
+ 'type': 'object'},
'InitiateMigrationArgs': {'additionalProperties': False,
'properties': {'specs': {'items': {'$ref': '#/definitions/MigrationSpec'},
'type': 'array'}},
'required': ['results'],
'type': 'object'},
'Macaroon': {'additionalProperties': False, 'type': 'object'},
+ 'MachineHardware': {'additionalProperties': False,
+ 'properties': {'arch': {'type': 'string'},
+ 'availability-zone': {'type': 'string'},
+ 'cores': {'type': 'integer'},
+ 'cpu-power': {'type': 'integer'},
+ 'mem': {'type': 'integer'},
+ 'root-disk': {'type': 'integer'},
+ 'tags': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'type': 'object'},
'MigrationSpec': {'additionalProperties': False,
- 'properties': {'model-tag': {'type': 'string'},
+ 'properties': {'external-control': {'type': 'boolean'},
+ 'model-tag': {'type': 'string'},
+ 'skip-initial-prechecks': {'type': 'boolean'},
'target-info': {'$ref': '#/definitions/MigrationTargetInfo'}},
- 'required': ['model-tag', 'target-info'],
+ 'required': ['model-tag',
+ 'target-info',
+ 'external-control',
+ 'skip-initial-prechecks'],
'type': 'object'},
'MigrationTargetInfo': {'additionalProperties': False,
'properties': {'addrs': {'items': {'type': 'string'},
'auth-tag': {'type': 'string'},
'ca-cert': {'type': 'string'},
'controller-tag': {'type': 'string'},
- 'macaroon': {'type': 'string'},
+ 'macaroons': {'type': 'string'},
'password': {'type': 'string'}},
'required': ['controller-tag',
'addrs',
'type': 'object'}},
'required': ['config'],
'type': 'object'},
+ 'ModelMachineInfo': {'additionalProperties': False,
+ 'properties': {'hardware': {'$ref': '#/definitions/MachineHardware'},
+ 'has-vote': {'type': 'boolean'},
+ 'id': {'type': 'string'},
+ 'instance-id': {'type': 'string'},
+ 'status': {'type': 'string'},
+ 'wants-vote': {'type': 'boolean'}},
+ 'required': ['id'],
+ 'type': 'object'},
'ModelStatus': {'additionalProperties': False,
'properties': {'application-count': {'type': 'integer'},
'hosted-machine-count': {'type': 'integer'},
'life': {'type': 'string'},
+ 'machines': {'items': {'$ref': '#/definitions/ModelMachineInfo'},
+ 'type': 'array'},
'model-tag': {'type': 'string'},
'owner-tag': {'type': 'string'}},
'required': ['model-tag',
'type': 'array'}},
'required': ['models'],
'type': 'object'},
+ 'ModelTag': {'additionalProperties': False, 'type': 'object'},
'ModifyControllerAccess': {'additionalProperties': False,
'properties': {'access': {'type': 'string'},
'action': {'type': 'string'},
'type': 'object'},
'DestroyController': {'properties': {'Params': {'$ref': '#/definitions/DestroyControllerArgs'}},
'type': 'object'},
+ 'GetCloudSpec': {'properties': {'Params': {'$ref': '#/definitions/ModelTag'},
+ 'Result': {'$ref': '#/definitions/CloudSpecResult'}},
+ 'type': 'object'},
'GetControllerAccess': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
'Result': {'$ref': '#/definitions/UserAccessResults'}},
'type': 'object'},
+ 'HostedModelConfigs': {'properties': {'Result': {'$ref': '#/definitions/HostedModelConfigsResults'}},
+ 'type': 'object'},
'InitiateMigration': {'properties': {'Params': {'$ref': '#/definitions/InitiateMigrationArgs'},
'Result': {'$ref': '#/definitions/InitiateMigrationResults'}},
'type': 'object'},
Returns -> typing.Sequence<+T_co>[~UserModel]<~UserModel>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='AllModels', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Controller', request='AllModels', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~CloudSpecResult]<~CloudSpecResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='CloudSpec', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Controller', request='CloudSpec', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='ControllerConfig', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Controller', request='ControllerConfig', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='DestroyController', version=3, params=params)
- params['destroy-models'] = destroy_models
+ _params = dict()
+ msg = dict(type='Controller', request='DestroyController', version=3, params=_params)
+ _params['destroy-models'] = destroy_models
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(CloudSpecResult)
+ async def GetCloudSpec(self):
+ '''
+
+ Returns -> typing.Union[_ForwardRef('Error'), _ForwardRef('CloudSpec')]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Controller', request='GetCloudSpec', version=3, params=_params)
+
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~UserAccessResult]<~UserAccessResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='GetControllerAccess', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Controller', request='GetControllerAccess', version=3, params=_params)
+ _params['entities'] = entities
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(HostedModelConfigsResults)
+ async def HostedModelConfigs(self):
+ '''
+
+ Returns -> typing.Sequence<+T_co>[~HostedModelConfig]<~HostedModelConfig>
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Controller', request='HostedModelConfigs', version=3, params=_params)
+
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~InitiateMigrationResult]<~InitiateMigrationResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='InitiateMigration', version=3, params=params)
- params['specs'] = specs
+ _params = dict()
+ msg = dict(type='Controller', request='InitiateMigration', version=3, params=_params)
+ _params['specs'] = specs
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ModelBlockInfo]<~ModelBlockInfo>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='ListBlockedModels', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Controller', request='ListBlockedModels', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, ~ConfigValue]<~ConfigValue>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='ModelConfig', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Controller', request='ModelConfig', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ModelStatus]<~ModelStatus>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='ModelStatus', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Controller', request='ModelStatus', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='ModifyControllerAccess', version=3, params=params)
- params['changes'] = changes
+ _params = dict()
+ msg = dict(type='Controller', request='ModifyControllerAccess', version=3, params=_params)
+ _params['changes'] = changes
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='RemoveBlocks', version=3, params=params)
- params['all'] = all_
+ _params = dict()
+ msg = dict(type='Controller', request='RemoveBlocks', version=3, params=_params)
+ _params['all'] = all_
reply = await self.rpc(msg)
return reply
Returns -> str
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Controller', request='WatchAllModels', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Controller', request='WatchAllModels', version=3, params=_params)
reply = await self.rpc(msg)
return reply
'type': 'array'}},
'required': ['changes'],
'type': 'object'},
+ 'EntityStatusArgs': {'additionalProperties': False,
+ 'properties': {'data': {'patternProperties': {'.*': {'additionalProperties': True,
+ 'type': 'object'}},
+ 'type': 'object'},
+ 'info': {'type': 'string'},
+ 'status': {'type': 'string'},
+ 'tag': {'type': 'string'}},
+ 'required': ['tag',
+ 'status',
+ 'info',
+ 'data'],
+ 'type': 'object'},
'Error': {'additionalProperties': False,
'properties': {'code': {'type': 'string'},
'info': {'$ref': '#/definitions/ErrorInfo'},
'error': {'$ref': '#/definitions/Error'}},
'required': ['NotifyWatcherId'],
'type': 'object'},
+ 'SetStatus': {'additionalProperties': False,
+ 'properties': {'entities': {'items': {'$ref': '#/definitions/EntityStatusArgs'},
+ 'type': 'array'}},
+ 'required': ['entities'],
+ 'type': 'object'},
'StringResult': {'additionalProperties': False,
'properties': {'error': {'$ref': '#/definitions/Error'},
'result': {'type': 'string'}},
'SetPasswords': {'properties': {'Params': {'$ref': '#/definitions/EntityPasswords'},
'Result': {'$ref': '#/definitions/ErrorResults'}},
'type': 'object'},
+ 'SetStatus': {'properties': {'Params': {'$ref': '#/definitions/SetStatus'},
+ 'Result': {'$ref': '#/definitions/ErrorResults'}},
+ 'type': 'object'},
'StateAddresses': {'properties': {'Result': {'$ref': '#/definitions/StringsResult'}},
'type': 'object'},
+ 'UpdateStatus': {'properties': {'Params': {'$ref': '#/definitions/SetStatus'},
+ 'Result': {'$ref': '#/definitions/ErrorResults'}},
+ 'type': 'object'},
'WatchAPIHostPorts': {'properties': {'Result': {'$ref': '#/definitions/NotifyWatchResult'}},
'type': 'object'},
'WatchUnits': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence<+T_co>[str]]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Deployer', request='APIAddresses', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Deployer', request='APIAddresses', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~HostPort]<~HostPort>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Deployer', request='APIHostPorts', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Deployer', request='APIHostPorts', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[int]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Deployer', request='CACert', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Deployer', request='CACert', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Deployer', request='ConnectionInfo', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Deployer', request='ConnectionInfo', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Deployer', request='Life', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Deployer', request='Life', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Deployer', request='ModelUUID', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Deployer', request='ModelUUID', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Deployer', request='Remove', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Deployer', request='Remove', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Deployer', request='SetPasswords', version=1, params=params)
- params['changes'] = changes
+ _params = dict()
+ msg = dict(type='Deployer', request='SetPasswords', version=1, params=_params)
+ _params['changes'] = changes
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ErrorResults)
+ async def SetStatus(self, entities):
+ '''
+ entities : typing.Sequence<+T_co>[~EntityStatusArgs]<~EntityStatusArgs>
+ Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Deployer', request='SetStatus', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence<+T_co>[str]]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Deployer', request='StateAddresses', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Deployer', request='StateAddresses', version=1, params=_params)
+
+ reply = await self.rpc(msg)
+ return reply
+
+
+ @ReturnMapping(ErrorResults)
+ async def UpdateStatus(self, entities):
+ '''
+ entities : typing.Sequence<+T_co>[~EntityStatusArgs]<~EntityStatusArgs>
+ Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Deployer', request='UpdateStatus', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Deployer', request='WatchAPIHostPorts', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Deployer', request='WatchAPIHostPorts', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Deployer', request='WatchUnits', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Deployer', request='WatchUnits', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='DiscoverSpaces', request='AddSubnets', version=2, params=params)
- params['subnets'] = subnets
+ _params = dict()
+ msg = dict(type='DiscoverSpaces', request='AddSubnets', version=2, params=_params)
+ _params['subnets'] = subnets
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='DiscoverSpaces', request='CreateSpaces', version=2, params=params)
- params['spaces'] = spaces
+ _params = dict()
+ msg = dict(type='DiscoverSpaces', request='CreateSpaces', version=2, params=_params)
+ _params['spaces'] = spaces
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ProviderSpace]<~ProviderSpace>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='DiscoverSpaces', request='ListSpaces', version=2, params=params)
+ _params = dict()
+ msg = dict(type='DiscoverSpaces', request='ListSpaces', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~Subnet]<~Subnet>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='DiscoverSpaces', request='ListSubnets', version=2, params=params)
- params['space-tag'] = space_tag
- params['zone'] = zone
+ _params = dict()
+ msg = dict(type='DiscoverSpaces', request='ListSubnets', version=2, params=_params)
+ _params['space-tag'] = space_tag
+ _params['zone'] = zone
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='DiscoverSpaces', request='ModelConfig', version=2, params=params)
+ _params = dict()
+ msg = dict(type='DiscoverSpaces', request='ModelConfig', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='DiskManager', request='SetMachineBlockDevices', version=2, params=params)
- params['machine-block-devices'] = machine_block_devices
+ _params = dict()
+ msg = dict(type='DiskManager', request='SetMachineBlockDevices', version=2, params=_params)
+ _params['machine-block-devices'] = machine_block_devices
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[typing.Sequence<+T_co>[str], _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='EntityWatcher', request='Next', version=2, params=params)
+ _params = dict()
+ msg = dict(type='EntityWatcher', request='Next', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='EntityWatcher', request='Stop', version=2, params=params)
+ _params = dict()
+ msg = dict(type='EntityWatcher', request='Stop', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='FilesystemAttachmentsWatcher', request='Next', version=2, params=params)
+ _params = dict()
+ msg = dict(type='FilesystemAttachmentsWatcher', request='Next', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='FilesystemAttachmentsWatcher', request='Stop', version=2, params=params)
+ _params = dict()
+ msg = dict(type='FilesystemAttachmentsWatcher', request='Stop', version=2, params=_params)
reply = await self.rpc(msg)
return reply
'type': 'object'}},
'required': ['config'],
'type': 'object'},
+ 'ModelTag': {'additionalProperties': False, 'type': 'object'},
'NotifyWatchResult': {'additionalProperties': False,
'properties': {'NotifyWatcherId': {'type': 'string'},
'error': {'$ref': '#/definitions/Error'}},
'GetAssignedMachine': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
'Result': {'$ref': '#/definitions/StringResults'}},
'type': 'object'},
+ 'GetCloudSpec': {'properties': {'Params': {'$ref': '#/definitions/ModelTag'},
+ 'Result': {'$ref': '#/definitions/CloudSpecResult'}},
+ 'type': 'object'},
'GetExposed': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
'Result': {'$ref': '#/definitions/BoolResults'}},
'type': 'object'},
Returns -> typing.Sequence<+T_co>[~CloudSpecResult]<~CloudSpecResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='CloudSpec', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Firewaller', request='CloudSpec', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='GetAssignedMachine', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Firewaller', request='GetAssignedMachine', version=3, params=_params)
+ _params['entities'] = entities
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(CloudSpecResult)
+ async def GetCloudSpec(self):
+ '''
+
+ Returns -> typing.Union[_ForwardRef('Error'), _ForwardRef('CloudSpec')]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Firewaller', request='GetCloudSpec', version=3, params=_params)
+
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~BoolResult]<~BoolResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='GetExposed', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Firewaller', request='GetExposed', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsResult]<~StringsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='GetMachineActiveSubnets', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Firewaller', request='GetMachineActiveSubnets', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~MachinePortsResult]<~MachinePortsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='GetMachinePorts', version=3, params=params)
- params['params'] = params
+ _params = dict()
+ msg = dict(type='Firewaller', request='GetMachinePorts', version=3, params=_params)
+ _params['params'] = params
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='InstanceId', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Firewaller', request='InstanceId', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='Life', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Firewaller', request='Life', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='ModelConfig', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Firewaller', request='ModelConfig', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='Watch', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Firewaller', request='Watch', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='WatchForModelConfigChanges', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Firewaller', request='WatchForModelConfigChanges', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[typing.Sequence<+T_co>[str], _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='WatchModelMachines', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Firewaller', request='WatchModelMachines', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='WatchOpenedPorts', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Firewaller', request='WatchOpenedPorts', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Firewaller', request='WatchUnits', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Firewaller', request='WatchUnits', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
'type': 'object'},
'ControllersSpec': {'additionalProperties': False,
'properties': {'constraints': {'$ref': '#/definitions/Value'},
- 'model-tag': {'type': 'string'},
'num-controllers': {'type': 'integer'},
'placement': {'items': {'type': 'string'},
'type': 'array'},
'series': {'type': 'string'}},
- 'required': ['model-tag',
- 'num-controllers'],
+ 'required': ['num-controllers'],
'type': 'object'},
'ControllersSpecs': {'additionalProperties': False,
'properties': {'specs': {'items': {'$ref': '#/definitions/ControllersSpec'},
'master',
'ha-members'],
'type': 'object'},
+ 'MongoVersion': {'additionalProperties': False,
+ 'properties': {'engine': {'type': 'string'},
+ 'major': {'type': 'integer'},
+ 'minor': {'type': 'integer'},
+ 'patch': {'type': 'string'}},
+ 'required': ['major',
+ 'minor',
+ 'patch',
+ 'engine'],
+ 'type': 'object'},
'ResumeReplicationParams': {'additionalProperties': False,
'properties': {'members': {'items': {'$ref': '#/definitions/Member'},
'type': 'array'}},
'required': ['members'],
'type': 'object'},
'UpgradeMongoParams': {'additionalProperties': False,
- 'properties': {'target': {'$ref': '#/definitions/Version'}},
+ 'properties': {'target': {'$ref': '#/definitions/MongoVersion'}},
'required': ['target'],
'type': 'object'},
'Value': {'additionalProperties': False,
'properties': {'arch': {'type': 'string'},
'container': {'type': 'string'},
- 'cpu-cores': {'type': 'integer'},
+ 'cores': {'type': 'integer'},
'cpu-power': {'type': 'integer'},
'instance-type': {'type': 'string'},
'mem': {'type': 'integer'},
'tags': {'items': {'type': 'string'},
'type': 'array'},
'virt-type': {'type': 'string'}},
- 'type': 'object'},
- 'Version': {'additionalProperties': False,
- 'properties': {'Major': {'type': 'integer'},
- 'Minor': {'type': 'integer'},
- 'Patch': {'type': 'string'},
- 'StorageEngine': {'type': 'string'}},
- 'required': ['Major',
- 'Minor',
- 'Patch',
- 'StorageEngine'],
- 'type': 'object'}},
+ 'type': 'object'}},
'properties': {'EnableHA': {'properties': {'Params': {'$ref': '#/definitions/ControllersSpecs'},
'Result': {'$ref': '#/definitions/ControllersChangeResults'}},
'type': 'object'},
Returns -> typing.Sequence<+T_co>[~ControllersChangeResult]<~ControllersChangeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='HighAvailability', request='EnableHA', version=2, params=params)
- params['specs'] = specs
+ _params = dict()
+ msg = dict(type='HighAvailability', request='EnableHA', version=2, params=_params)
+ _params['specs'] = specs
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='HighAvailability', request='ResumeHAReplicationAfterUpgrade', version=2, params=params)
- params['members'] = members
+ _params = dict()
+ msg = dict(type='HighAvailability', request='ResumeHAReplicationAfterUpgrade', version=2, params=_params)
+ _params['members'] = members
reply = await self.rpc(msg)
return reply
@ReturnMapping(MongoUpgradeResults)
- async def StopHAReplicationForUpgrade(self, major, minor, patch, storageengine):
+ async def StopHAReplicationForUpgrade(self, target):
'''
- major : int
- minor : int
- patch : str
- storageengine : str
+ target : MongoVersion
Returns -> typing.Union[_ForwardRef('HAMember'), typing.Sequence<+T_co>[~Member]<~Member>]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='HighAvailability', request='StopHAReplicationForUpgrade', version=2, params=params)
- params['Major'] = major
- params['Minor'] = minor
- params['Patch'] = patch
- params['StorageEngine'] = storageengine
+ _params = dict()
+ msg = dict(type='HighAvailability', request='StopHAReplicationForUpgrade', version=2, params=_params)
+ _params['target'] = target
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='HostKeyReporter', request='ReportKeys', version=1, params=params)
- params['entity-keys'] = entity_keys
+ _params = dict()
+ msg = dict(type='HostKeyReporter', request='ReportKeys', version=1, params=_params)
+ _params['entity-keys'] = entity_keys
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ImageManager', request='DeleteImages', version=2, params=params)
- params['images'] = images
+ _params = dict()
+ msg = dict(type='ImageManager', request='DeleteImages', version=2, params=_params)
+ _params['images'] = images
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ImageMetadata]<~ImageMetadata>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ImageManager', request='ListImages', version=2, params=params)
- params['images'] = images
+ _params = dict()
+ msg = dict(type='ImageManager', request='ListImages', version=2, params=_params)
+ _params['images'] = images
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ImageMetadata', request='Delete', version=2, params=params)
- params['image-ids'] = image_ids
+ _params = dict()
+ msg = dict(type='ImageMetadata', request='Delete', version=2, params=_params)
+ _params['image-ids'] = image_ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~CloudImageMetadata]<~CloudImageMetadata>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ImageMetadata', request='List', version=2, params=params)
- params['arches'] = arches
- params['region'] = region
- params['root-storage-type'] = root_storage_type
- params['series'] = series
- params['stream'] = stream
- params['virt-type'] = virt_type
+ _params = dict()
+ msg = dict(type='ImageMetadata', request='List', version=2, params=_params)
+ _params['arches'] = arches
+ _params['region'] = region
+ _params['root-storage-type'] = root_storage_type
+ _params['series'] = series
+ _params['stream'] = stream
+ _params['virt-type'] = virt_type
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ImageMetadata', request='Save', version=2, params=params)
- params['metadata'] = metadata
+ _params = dict()
+ msg = dict(type='ImageMetadata', request='Save', version=2, params=_params)
+ _params['metadata'] = metadata
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ImageMetadata', request='UpdateFromPublishedImages', version=2, params=params)
+ _params = dict()
+ msg = dict(type='ImageMetadata', request='UpdateFromPublishedImages', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~BoolResult]<~BoolResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='InstancePoller', request='AreManuallyProvisioned', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='InstancePoller', request='AreManuallyProvisioned', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='InstancePoller', request='InstanceId', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='InstancePoller', request='InstanceId', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='InstancePoller', request='InstanceStatus', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='InstancePoller', request='InstanceStatus', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='InstancePoller', request='Life', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='InstancePoller', request='Life', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='InstancePoller', request='ModelConfig', version=3, params=params)
+ _params = dict()
+ msg = dict(type='InstancePoller', request='ModelConfig', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~MachineAddressesResult]<~MachineAddressesResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='InstancePoller', request='ProviderAddresses', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='InstancePoller', request='ProviderAddresses', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='InstancePoller', request='SetInstanceStatus', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='InstancePoller', request='SetInstanceStatus', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='InstancePoller', request='SetProviderAddresses', version=3, params=params)
- params['machine-addresses'] = machine_addresses
+ _params = dict()
+ msg = dict(type='InstancePoller', request='SetProviderAddresses', version=3, params=_params)
+ _params['machine-addresses'] = machine_addresses
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='InstancePoller', request='Status', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='InstancePoller', request='Status', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='InstancePoller', request='WatchForModelConfigChanges', version=3, params=params)
+ _params = dict()
+ msg = dict(type='InstancePoller', request='WatchForModelConfigChanges', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[typing.Sequence<+T_co>[str], _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='InstancePoller', request='WatchModelMachines', version=3, params=params)
+ _params = dict()
+ msg = dict(type='InstancePoller', request='WatchModelMachines', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='KeyManager', request='AddKeys', version=1, params=params)
- params['ssh-keys'] = ssh_keys
- params['user'] = user
+ _params = dict()
+ msg = dict(type='KeyManager', request='AddKeys', version=1, params=_params)
+ _params['ssh-keys'] = ssh_keys
+ _params['user'] = user
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='KeyManager', request='DeleteKeys', version=1, params=params)
- params['ssh-keys'] = ssh_keys
- params['user'] = user
+ _params = dict()
+ msg = dict(type='KeyManager', request='DeleteKeys', version=1, params=_params)
+ _params['ssh-keys'] = ssh_keys
+ _params['user'] = user
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='KeyManager', request='ImportKeys', version=1, params=params)
- params['ssh-keys'] = ssh_keys
- params['user'] = user
+ _params = dict()
+ msg = dict(type='KeyManager', request='ImportKeys', version=1, params=_params)
+ _params['ssh-keys'] = ssh_keys
+ _params['user'] = user
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsResult]<~StringsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='KeyManager', request='ListKeys', version=1, params=params)
- params['entities'] = entities
- params['mode'] = mode
+ _params = dict()
+ msg = dict(type='KeyManager', request='ListKeys', version=1, params=_params)
+ _params['entities'] = entities
+ _params['mode'] = mode
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsResult]<~StringsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='KeyUpdater', request='AuthorisedKeys', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='KeyUpdater', request='AuthorisedKeys', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='KeyUpdater', request='WatchAuthorisedKeys', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='KeyUpdater', request='WatchAuthorisedKeys', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> Error
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='LeadershipService', request='BlockUntilLeadershipReleased', version=2, params=params)
- params['Name'] = name
+ _params = dict()
+ msg = dict(type='LeadershipService', request='BlockUntilLeadershipReleased', version=2, params=_params)
+ _params['Name'] = name
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='LeadershipService', request='ClaimLeadership', version=2, params=params)
- params['params'] = params
+ _params = dict()
+ msg = dict(type='LeadershipService', request='ClaimLeadership', version=2, params=_params)
+ _params['params'] = params
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='LifeFlag', request='Life', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='LifeFlag', request='Life', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='LifeFlag', request='Watch', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='LifeFlag', request='Watch', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~LogForwardingGetLastSentResult]<~LogForwardingGetLastSentResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='LogForwarding', request='GetLastSent', version=1, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='LogForwarding', request='GetLastSent', version=1, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='LogForwarding', request='SetLastSent', version=1, params=params)
- params['params'] = params
+ _params = dict()
+ msg = dict(type='LogForwarding', request='SetLastSent', version=1, params=_params)
+ _params['params'] = params
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Logger', request='LoggingConfig', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Logger', request='LoggingConfig', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Logger', request='WatchLoggingConfig', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Logger', request='WatchLoggingConfig', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MachineActions', request='Actions', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MachineActions', request='Actions', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MachineActions', request='BeginActions', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MachineActions', request='BeginActions', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MachineActions', request='FinishActions', version=1, params=params)
- params['results'] = results
+ _params = dict()
+ msg = dict(type='MachineActions', request='FinishActions', version=1, params=_params)
+ _params['results'] = results
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionsByReceiver]<~ActionsByReceiver>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MachineActions', request='RunningActions', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MachineActions', request='RunningActions', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MachineActions', request='WatchActionNotifications', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MachineActions', request='WatchActionNotifications', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
'Value': {'additionalProperties': False,
'properties': {'arch': {'type': 'string'},
'container': {'type': 'string'},
- 'cpu-cores': {'type': 'integer'},
+ 'cores': {'type': 'integer'},
'cpu-power': {'type': 'integer'},
'instance-type': {'type': 'string'},
'mem': {'type': 'integer'},
Returns -> typing.Sequence<+T_co>[~AddMachinesResult]<~AddMachinesResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MachineManager', request='AddMachines', version=2, params=params)
- params['params'] = params
+ _params = dict()
+ msg = dict(type='MachineManager', request='AddMachines', version=2, params=_params)
+ _params['params'] = params
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~EntitiesResult]<~EntitiesResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MachineUndertaker', request='AllMachineRemovals', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MachineUndertaker', request='AllMachineRemovals', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MachineUndertaker', request='CompleteMachineRemovals', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MachineUndertaker', request='CompleteMachineRemovals', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ProviderInterfaceInfoResult]<~ProviderInterfaceInfoResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MachineUndertaker', request='GetMachineProviderInterfaceInfo', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MachineUndertaker', request='GetMachineProviderInterfaceInfo', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MachineUndertaker', request='WatchMachineRemovals', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MachineUndertaker', request='WatchMachineRemovals', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence<+T_co>[str]]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='APIAddresses', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Machiner', request='APIAddresses', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~HostPort]<~HostPort>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='APIHostPorts', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Machiner', request='APIHostPorts', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[int]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='CACert', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Machiner', request='CACert', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='EnsureDead', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Machiner', request='EnsureDead', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~JobsResult]<~JobsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='Jobs', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Machiner', request='Jobs', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='Life', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Machiner', request='Life', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='ModelUUID', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Machiner', request='ModelUUID', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='SetMachineAddresses', version=1, params=params)
- params['machine-addresses'] = machine_addresses
+ _params = dict()
+ msg = dict(type='Machiner', request='SetMachineAddresses', version=1, params=_params)
+ _params['machine-addresses'] = machine_addresses
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='SetObservedNetworkConfig', version=1, params=params)
- params['config'] = config
- params['tag'] = tag
+ _params = dict()
+ msg = dict(type='Machiner', request='SetObservedNetworkConfig', version=1, params=_params)
+ _params['config'] = config
+ _params['tag'] = tag
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='SetProviderNetworkConfig', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Machiner', request='SetProviderNetworkConfig', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='SetStatus', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Machiner', request='SetStatus', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='UpdateStatus', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Machiner', request='UpdateStatus', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='Watch', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Machiner', request='Watch', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Machiner', request='WatchAPIHostPorts', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Machiner', request='WatchAPIHostPorts', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~MeterStatusResult]<~MeterStatusResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MeterStatus', request='GetMeterStatus', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MeterStatus', request='GetMeterStatus', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MeterStatus', request='WatchMeterStatus', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MeterStatus', request='WatchMeterStatus', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MetricsAdder', request='AddMetricBatches', version=2, params=params)
- params['batches'] = batches
+ _params = dict()
+ msg = dict(type='MetricsAdder', request='AddMetricBatches', version=2, params=_params)
+ _params['batches'] = batches
reply = await self.rpc(msg)
return reply
'properties': {'key': {'type': 'string'},
'time': {'format': 'date-time',
'type': 'string'},
+ 'unit': {'type': 'string'},
'value': {'type': 'string'}},
- 'required': ['time', 'key', 'value'],
+ 'required': ['time', 'key', 'value', 'unit'],
'type': 'object'},
'MetricResults': {'additionalProperties': False,
'properties': {'results': {'items': {'$ref': '#/definitions/EntityMetrics'},
Returns -> typing.Sequence<+T_co>[~EntityMetrics]<~EntityMetrics>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MetricsDebug', request='GetMetrics', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MetricsDebug', request='GetMetrics', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MetricsDebug', request='SetMeterStatus', version=2, params=params)
- params['statues'] = statues
+ _params = dict()
+ msg = dict(type='MetricsDebug', request='SetMeterStatus', version=2, params=_params)
+ _params['statues'] = statues
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MetricsManager', request='CleanupOldMetrics', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MetricsManager', request='CleanupOldMetrics', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MetricsManager', request='SendMetrics', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MetricsManager', request='SendMetrics', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~PhaseResult]<~PhaseResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationFlag', request='Phase', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MigrationFlag', request='Phase', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationFlag', request='Watch', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='MigrationFlag', request='Watch', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
'MigrationModelInfo': {'additionalProperties': False,
'properties': {'agent-version': {'$ref': '#/definitions/Number'},
'name': {'type': 'string'},
+ 'owner-tag': {'type': 'string'},
'uuid': {'type': 'string'}},
'required': ['uuid',
'name',
+ 'owner-tag',
'agent-version'],
'type': 'object'},
'MigrationSpec': {'additionalProperties': False,
- 'properties': {'model-tag': {'type': 'string'},
+ 'properties': {'external-control': {'type': 'boolean'},
+ 'model-tag': {'type': 'string'},
+ 'skip-initial-prechecks': {'type': 'boolean'},
'target-info': {'$ref': '#/definitions/MigrationTargetInfo'}},
- 'required': ['model-tag', 'target-info'],
+ 'required': ['model-tag',
+ 'target-info',
+ 'external-control',
+ 'skip-initial-prechecks'],
'type': 'object'},
'MigrationTargetInfo': {'additionalProperties': False,
'properties': {'addrs': {'items': {'type': 'string'},
'auth-tag': {'type': 'string'},
'ca-cert': {'type': 'string'},
'controller-tag': {'type': 'string'},
- 'macaroon': {'type': 'string'},
+ 'macaroons': {'type': 'string'},
'password': {'type': 'string'}},
'required': ['controller-tag',
'addrs',
Returns -> typing.Sequence<+T_co>[~SerializedModelTools]<~SerializedModelTools>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMaster', request='Export', version=1, params=params)
+ _params = dict()
+ msg = dict(type='MigrationMaster', request='Export', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('MigrationSpec')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMaster', request='MigrationStatus', version=1, params=params)
+ _params = dict()
+ msg = dict(type='MigrationMaster', request='MigrationStatus', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[typing.Sequence<+T_co>[str], int]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMaster', request='MinionReports', version=1, params=params)
+ _params = dict()
+ msg = dict(type='MigrationMaster', request='MinionReports', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Number'), str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMaster', request='ModelInfo', version=1, params=params)
+ _params = dict()
+ msg = dict(type='MigrationMaster', request='ModelInfo', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMaster', request='Prechecks', version=1, params=params)
+ _params = dict()
+ msg = dict(type='MigrationMaster', request='Prechecks', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMaster', request='Reap', version=1, params=params)
+ _params = dict()
+ msg = dict(type='MigrationMaster', request='Reap', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMaster', request='SetPhase', version=1, params=params)
- params['phase'] = phase
+ _params = dict()
+ msg = dict(type='MigrationMaster', request='SetPhase', version=1, params=_params)
+ _params['phase'] = phase
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMaster', request='SetStatusMessage', version=1, params=params)
- params['message'] = message
+ _params = dict()
+ msg = dict(type='MigrationMaster', request='SetStatusMessage', version=1, params=_params)
+ _params['message'] = message
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMaster', request='Watch', version=1, params=params)
+ _params = dict()
+ msg = dict(type='MigrationMaster', request='Watch', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMaster', request='WatchMinionReports', version=1, params=params)
+ _params = dict()
+ msg = dict(type='MigrationMaster', request='WatchMinionReports', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMinion', request='Report', version=1, params=params)
- params['migration-id'] = migration_id
- params['phase'] = phase
- params['success'] = success
+ _params = dict()
+ msg = dict(type='MigrationMinion', request='Report', version=1, params=_params)
+ _params['migration-id'] = migration_id
+ _params['phase'] = phase
+ _params['success'] = success
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationMinion', request='Watch', version=1, params=params)
+ _params = dict()
+ msg = dict(type='MigrationMinion', request='Watch', version=1, params=_params)
reply = await self.rpc(msg)
return reply
version = 1
schema = {'definitions': {'MigrationStatus': {'additionalProperties': False,
'properties': {'attempt': {'type': 'integer'},
+ 'external-control': {'type': 'boolean'},
'migration-id': {'type': 'string'},
'phase': {'type': 'string'},
'source-api-addrs': {'items': {'type': 'string'},
'required': ['migration-id',
'attempt',
'phase',
+ 'external-control',
'source-api-addrs',
'source-ca-cert',
'target-api-addrs',
Returns -> typing.Union[int, typing.Sequence<+T_co>[str]]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationStatusWatcher', request='Next', version=1, params=params)
+ _params = dict()
+ msg = dict(type='MigrationStatusWatcher', request='Next', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationStatusWatcher', request='Stop', version=1, params=params)
+ _params = dict()
+ msg = dict(type='MigrationStatusWatcher', request='Stop', version=1, params=_params)
reply = await self.rpc(msg)
return reply
class MigrationTargetFacade(Type):
name = 'MigrationTarget'
version = 1
- schema = {'definitions': {'ModelArgs': {'additionalProperties': False,
+ schema = {'definitions': {'MigrationModelInfo': {'additionalProperties': False,
+ 'properties': {'agent-version': {'$ref': '#/definitions/Number'},
+ 'name': {'type': 'string'},
+ 'owner-tag': {'type': 'string'},
+ 'uuid': {'type': 'string'}},
+ 'required': ['uuid',
+ 'name',
+ 'owner-tag',
+ 'agent-version'],
+ 'type': 'object'},
+ 'ModelArgs': {'additionalProperties': False,
'properties': {'model-tag': {'type': 'string'}},
'required': ['model-tag'],
'type': 'object'},
'properties': {'uri': {'type': 'string'},
'version': {'type': 'string'}},
'required': ['version', 'uri'],
- 'type': 'object'},
- 'TargetPrechecksArgs': {'additionalProperties': False,
- 'properties': {'agent-version': {'$ref': '#/definitions/Number'}},
- 'required': ['agent-version'],
- 'type': 'object'}},
+ 'type': 'object'}},
'properties': {'Abort': {'properties': {'Params': {'$ref': '#/definitions/ModelArgs'}},
'type': 'object'},
'Activate': {'properties': {'Params': {'$ref': '#/definitions/ModelArgs'}},
'type': 'object'},
'Import': {'properties': {'Params': {'$ref': '#/definitions/SerializedModel'}},
'type': 'object'},
- 'Prechecks': {'properties': {'Params': {'$ref': '#/definitions/TargetPrechecksArgs'}},
+ 'Prechecks': {'properties': {'Params': {'$ref': '#/definitions/MigrationModelInfo'}},
'type': 'object'}},
'type': 'object'}
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationTarget', request='Abort', version=1, params=params)
- params['model-tag'] = model_tag
+ _params = dict()
+ msg = dict(type='MigrationTarget', request='Abort', version=1, params=_params)
+ _params['model-tag'] = model_tag
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationTarget', request='Activate', version=1, params=params)
- params['model-tag'] = model_tag
+ _params = dict()
+ msg = dict(type='MigrationTarget', request='Activate', version=1, params=_params)
+ _params['model-tag'] = model_tag
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationTarget', request='Import', version=1, params=params)
- params['bytes'] = bytes_
- params['charms'] = charms
- params['tools'] = tools
+ _params = dict()
+ msg = dict(type='MigrationTarget', request='Import', version=1, params=_params)
+ _params['bytes'] = bytes_
+ _params['charms'] = charms
+ _params['tools'] = tools
reply = await self.rpc(msg)
return reply
@ReturnMapping(None)
- async def Prechecks(self, build, major, minor, patch, tag):
+ async def Prechecks(self, agent_version, name, owner_tag, uuid):
'''
- build : int
- major : int
- minor : int
- patch : int
- tag : str
+ agent_version : Number
+ name : str
+ owner_tag : str
+ uuid : str
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='MigrationTarget', request='Prechecks', version=1, params=params)
- params['Build'] = build
- params['Major'] = major
- params['Minor'] = minor
- params['Patch'] = patch
- params['Tag'] = tag
+ _params = dict()
+ msg = dict(type='MigrationTarget', request='Prechecks', version=1, params=_params)
+ _params['agent-version'] = agent_version
+ _params['name'] = name
+ _params['owner-tag'] = owner_tag
+ _params['uuid'] = uuid
reply = await self.rpc(msg)
return reply
schema = {'definitions': {'ConfigValue': {'additionalProperties': False,
'properties': {'source': {'type': 'string'},
'value': {'additionalProperties': True,
- 'type': 'object'}},
- 'required': ['value', 'source'],
- 'type': 'object'},
- 'Error': {'additionalProperties': False,
- 'properties': {'code': {'type': 'string'},
- 'info': {'$ref': '#/definitions/ErrorInfo'},
- 'message': {'type': 'string'}},
- 'required': ['message', 'code'],
- 'type': 'object'},
- 'ErrorInfo': {'additionalProperties': False,
- 'properties': {'macaroon': {'$ref': '#/definitions/Macaroon'},
- 'macaroon-path': {'type': 'string'}},
- 'type': 'object'},
- 'ErrorResult': {'additionalProperties': False,
- 'properties': {'error': {'$ref': '#/definitions/Error'}},
- 'type': 'object'},
- 'ErrorResults': {'additionalProperties': False,
- 'properties': {'results': {'items': {'$ref': '#/definitions/ErrorResult'},
- 'type': 'array'}},
- 'required': ['results'],
- 'type': 'object'},
- 'Macaroon': {'additionalProperties': False, 'type': 'object'},
- 'ModelConfigResults': {'additionalProperties': False,
- 'properties': {'config': {'patternProperties': {'.*': {'$ref': '#/definitions/ConfigValue'}},
- 'type': 'object'}},
- 'required': ['config'],
- 'type': 'object'},
- 'ModelDefaultValues': {'additionalProperties': False,
- 'properties': {'cloud-region': {'type': 'string'},
- 'cloud-tag': {'type': 'string'},
- 'config': {'patternProperties': {'.*': {'additionalProperties': True,
- 'type': 'object'}},
- 'type': 'object'}},
- 'required': ['config'],
- 'type': 'object'},
- 'ModelDefaults': {'additionalProperties': False,
- 'properties': {'controller': {'additionalProperties': True,
- 'type': 'object'},
- 'default': {'additionalProperties': True,
- 'type': 'object'},
- 'regions': {'items': {'$ref': '#/definitions/RegionDefaults'},
- 'type': 'array'}},
- 'type': 'object'},
- 'ModelDefaultsResult': {'additionalProperties': False,
- 'properties': {'config': {'patternProperties': {'.*': {'$ref': '#/definitions/ModelDefaults'}},
- 'type': 'object'}},
- 'required': ['config'],
- 'type': 'object'},
+ 'type': 'object'}},
+ 'required': ['value', 'source'],
+ 'type': 'object'},
+ 'ModelConfigResults': {'additionalProperties': False,
+ 'properties': {'config': {'patternProperties': {'.*': {'$ref': '#/definitions/ConfigValue'}},
+ 'type': 'object'}},
+ 'required': ['config'],
+ 'type': 'object'},
'ModelSet': {'additionalProperties': False,
'properties': {'config': {'patternProperties': {'.*': {'additionalProperties': True,
'type': 'object'}},
'properties': {'keys': {'items': {'type': 'string'},
'type': 'array'}},
'required': ['keys'],
- 'type': 'object'},
- 'ModelUnsetKeys': {'additionalProperties': False,
- 'properties': {'cloud-region': {'type': 'string'},
- 'cloud-tag': {'type': 'string'},
- 'keys': {'items': {'type': 'string'},
- 'type': 'array'}},
- 'required': ['keys'],
- 'type': 'object'},
- 'RegionDefaults': {'additionalProperties': False,
- 'properties': {'region-name': {'type': 'string'},
- 'value': {'additionalProperties': True,
- 'type': 'object'}},
- 'required': ['region-name', 'value'],
- 'type': 'object'},
- 'SetModelDefaults': {'additionalProperties': False,
- 'properties': {'config': {'items': {'$ref': '#/definitions/ModelDefaultValues'},
- 'type': 'array'}},
- 'required': ['config'],
- 'type': 'object'},
- 'UnsetModelDefaults': {'additionalProperties': False,
- 'properties': {'keys': {'items': {'$ref': '#/definitions/ModelUnsetKeys'},
- 'type': 'array'}},
- 'required': ['keys'],
- 'type': 'object'}},
- 'properties': {'ModelDefaults': {'properties': {'Result': {'$ref': '#/definitions/ModelDefaultsResult'}},
- 'type': 'object'},
- 'ModelGet': {'properties': {'Result': {'$ref': '#/definitions/ModelConfigResults'}},
+ 'type': 'object'}},
+ 'properties': {'ModelGet': {'properties': {'Result': {'$ref': '#/definitions/ModelConfigResults'}},
'type': 'object'},
'ModelSet': {'properties': {'Params': {'$ref': '#/definitions/ModelSet'}},
'type': 'object'},
'ModelUnset': {'properties': {'Params': {'$ref': '#/definitions/ModelUnset'}},
- 'type': 'object'},
- 'SetModelDefaults': {'properties': {'Params': {'$ref': '#/definitions/SetModelDefaults'},
- 'Result': {'$ref': '#/definitions/ErrorResults'}},
- 'type': 'object'},
- 'UnsetModelDefaults': {'properties': {'Params': {'$ref': '#/definitions/UnsetModelDefaults'},
- 'Result': {'$ref': '#/definitions/ErrorResults'}},
- 'type': 'object'}},
+ 'type': 'object'}},
'type': 'object'}
- @ReturnMapping(ModelDefaultsResult)
- async def ModelDefaults(self):
- '''
-
- Returns -> typing.Mapping<~KT, +VT_co>[str, ~ModelDefaults]<~ModelDefaults>
- '''
- # map input types to rpc msg
- params = dict()
- msg = dict(type='ModelConfig', request='ModelDefaults', version=1, params=params)
-
- reply = await self.rpc(msg)
- return reply
-
-
-
@ReturnMapping(ModelConfigResults)
async def ModelGet(self):
'''
Returns -> typing.Mapping<~KT, +VT_co>[str, ~ConfigValue]<~ConfigValue>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ModelConfig', request='ModelGet', version=1, params=params)
+ _params = dict()
+ msg = dict(type='ModelConfig', request='ModelGet', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ModelConfig', request='ModelSet', version=1, params=params)
- params['config'] = config
+ _params = dict()
+ msg = dict(type='ModelConfig', request='ModelSet', version=1, params=_params)
+ _params['config'] = config
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ModelConfig', request='ModelUnset', version=1, params=params)
- params['keys'] = keys
- reply = await self.rpc(msg)
- return reply
-
-
-
- @ReturnMapping(ErrorResults)
- async def SetModelDefaults(self, config):
- '''
- config : typing.Sequence<+T_co>[~ModelDefaultValues]<~ModelDefaultValues>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
- '''
- # map input types to rpc msg
- params = dict()
- msg = dict(type='ModelConfig', request='SetModelDefaults', version=1, params=params)
- params['config'] = config
- reply = await self.rpc(msg)
- return reply
-
-
-
- @ReturnMapping(ErrorResults)
- async def UnsetModelDefaults(self, keys):
- '''
- keys : typing.Sequence<+T_co>[~ModelUnsetKeys]<~ModelUnsetKeys>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
- '''
- # map input types to rpc msg
- params = dict()
- msg = dict(type='ModelConfig', request='UnsetModelDefaults', version=1, params=params)
- params['keys'] = keys
+ _params = dict()
+ msg = dict(type='ModelConfig', request='ModelUnset', version=1, params=_params)
+ _params['keys'] = keys
reply = await self.rpc(msg)
return reply
'required': ['results'],
'type': 'object'},
'Macaroon': {'additionalProperties': False, 'type': 'object'},
+ 'MachineHardware': {'additionalProperties': False,
+ 'properties': {'arch': {'type': 'string'},
+ 'availability-zone': {'type': 'string'},
+ 'cores': {'type': 'integer'},
+ 'cpu-power': {'type': 'integer'},
+ 'mem': {'type': 'integer'},
+ 'root-disk': {'type': 'integer'},
+ 'tags': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'type': 'object'},
'MapResult': {'additionalProperties': False,
'properties': {'error': {'$ref': '#/definitions/Error'},
'result': {'patternProperties': {'.*': {'additionalProperties': True,
'region': {'type': 'string'}},
'required': ['name', 'owner-tag'],
'type': 'object'},
+ 'ModelDefaultValues': {'additionalProperties': False,
+ 'properties': {'cloud-region': {'type': 'string'},
+ 'cloud-tag': {'type': 'string'},
+ 'config': {'patternProperties': {'.*': {'additionalProperties': True,
+ 'type': 'object'}},
+ 'type': 'object'}},
+ 'required': ['config'],
+ 'type': 'object'},
+ 'ModelDefaults': {'additionalProperties': False,
+ 'properties': {'controller': {'additionalProperties': True,
+ 'type': 'object'},
+ 'default': {'additionalProperties': True,
+ 'type': 'object'},
+ 'regions': {'items': {'$ref': '#/definitions/RegionDefaults'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'ModelDefaultsResult': {'additionalProperties': False,
+ 'properties': {'config': {'patternProperties': {'.*': {'$ref': '#/definitions/ModelDefaults'}},
+ 'type': 'object'}},
+ 'required': ['config'],
+ 'type': 'object'},
'ModelInfo': {'additionalProperties': False,
- 'properties': {'cloud': {'type': 'string'},
- 'cloud-credential-tag': {'type': 'string'},
+ 'properties': {'cloud-credential-tag': {'type': 'string'},
'cloud-region': {'type': 'string'},
+ 'cloud-tag': {'type': 'string'},
'controller-uuid': {'type': 'string'},
'default-series': {'type': 'string'},
'life': {'type': 'string'},
+ 'machines': {'items': {'$ref': '#/definitions/ModelMachineInfo'},
+ 'type': 'array'},
'name': {'type': 'string'},
'owner-tag': {'type': 'string'},
'provider-type': {'type': 'string'},
'controller-uuid',
'provider-type',
'default-series',
- 'cloud',
+ 'cloud-tag',
'owner-tag',
'life',
'status',
- 'users'],
+ 'users',
+ 'machines'],
'type': 'object'},
'ModelInfoResult': {'additionalProperties': False,
'properties': {'error': {'$ref': '#/definitions/Error'},
'type': 'array'}},
'required': ['results'],
'type': 'object'},
+ 'ModelMachineInfo': {'additionalProperties': False,
+ 'properties': {'hardware': {'$ref': '#/definitions/MachineHardware'},
+ 'has-vote': {'type': 'boolean'},
+ 'id': {'type': 'string'},
+ 'instance-id': {'type': 'string'},
+ 'status': {'type': 'string'},
+ 'wants-vote': {'type': 'boolean'}},
+ 'required': ['id'],
+ 'type': 'object'},
+ 'ModelStatus': {'additionalProperties': False,
+ 'properties': {'application-count': {'type': 'integer'},
+ 'hosted-machine-count': {'type': 'integer'},
+ 'life': {'type': 'string'},
+ 'machines': {'items': {'$ref': '#/definitions/ModelMachineInfo'},
+ 'type': 'array'},
+ 'model-tag': {'type': 'string'},
+ 'owner-tag': {'type': 'string'}},
+ 'required': ['model-tag',
+ 'life',
+ 'hosted-machine-count',
+ 'application-count',
+ 'owner-tag'],
+ 'type': 'object'},
+ 'ModelStatusResults': {'additionalProperties': False,
+ 'properties': {'models': {'items': {'$ref': '#/definitions/ModelStatus'},
+ 'type': 'array'}},
+ 'required': ['models'],
+ 'type': 'object'},
+ 'ModelUnsetKeys': {'additionalProperties': False,
+ 'properties': {'cloud-region': {'type': 'string'},
+ 'cloud-tag': {'type': 'string'},
+ 'keys': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'required': ['keys'],
+ 'type': 'object'},
'ModelUserInfo': {'additionalProperties': False,
'properties': {'access': {'type': 'string'},
'display-name': {'type': 'string'},
'type': 'array'}},
'required': ['changes'],
'type': 'object'},
+ 'RegionDefaults': {'additionalProperties': False,
+ 'properties': {'region-name': {'type': 'string'},
+ 'value': {'additionalProperties': True,
+ 'type': 'object'}},
+ 'required': ['region-name', 'value'],
+ 'type': 'object'},
+ 'SetModelDefaults': {'additionalProperties': False,
+ 'properties': {'config': {'items': {'$ref': '#/definitions/ModelDefaultValues'},
+ 'type': 'array'}},
+ 'required': ['config'],
+ 'type': 'object'},
+ 'UnsetModelDefaults': {'additionalProperties': False,
+ 'properties': {'keys': {'items': {'$ref': '#/definitions/ModelUnsetKeys'},
+ 'type': 'array'}},
+ 'required': ['keys'],
+ 'type': 'object'},
'UserModel': {'additionalProperties': False,
'properties': {'last-connection': {'format': 'date-time',
'type': 'string'},
'properties': {'CreateModel': {'properties': {'Params': {'$ref': '#/definitions/ModelCreateArgs'},
'Result': {'$ref': '#/definitions/ModelInfo'}},
'type': 'object'},
- 'DestroyModel': {'type': 'object'},
'DestroyModels': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
'Result': {'$ref': '#/definitions/ErrorResults'}},
'type': 'object'},
'ListModels': {'properties': {'Params': {'$ref': '#/definitions/Entity'},
'Result': {'$ref': '#/definitions/UserModelList'}},
'type': 'object'},
+ 'ModelDefaults': {'properties': {'Result': {'$ref': '#/definitions/ModelDefaultsResult'}},
+ 'type': 'object'},
'ModelInfo': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
'Result': {'$ref': '#/definitions/ModelInfoResults'}},
'type': 'object'},
+ 'ModelStatus': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/ModelStatusResults'}},
+ 'type': 'object'},
'ModifyModelAccess': {'properties': {'Params': {'$ref': '#/definitions/ModifyModelAccessRequest'},
'Result': {'$ref': '#/definitions/ErrorResults'}},
- 'type': 'object'}},
+ 'type': 'object'},
+ 'SetModelDefaults': {'properties': {'Params': {'$ref': '#/definitions/SetModelDefaults'},
+ 'Result': {'$ref': '#/definitions/ErrorResults'}},
+ 'type': 'object'},
+ 'UnsetModelDefaults': {'properties': {'Params': {'$ref': '#/definitions/UnsetModelDefaults'},
+ 'Result': {'$ref': '#/definitions/ErrorResults'}},
+ 'type': 'object'}},
'type': 'object'}
Returns -> typing.Union[_ForwardRef('EntityStatus'), typing.Sequence<+T_co>[~ModelUserInfo]<~ModelUserInfo>]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ModelManager', request='CreateModel', version=2, params=params)
- params['cloud-tag'] = cloud_tag
- params['config'] = config
- params['credential'] = credential
- params['name'] = name
- params['owner-tag'] = owner_tag
- params['region'] = region
- reply = await self.rpc(msg)
- return reply
-
-
-
- @ReturnMapping(None)
- async def DestroyModel(self):
- '''
-
- Returns -> None
- '''
- # map input types to rpc msg
- params = dict()
- msg = dict(type='ModelManager', request='DestroyModel', version=2, params=params)
-
+ _params = dict()
+ msg = dict(type='ModelManager', request='CreateModel', version=2, params=_params)
+ _params['cloud-tag'] = cloud_tag
+ _params['config'] = config
+ _params['credential'] = credential
+ _params['name'] = name
+ _params['owner-tag'] = owner_tag
+ _params['region'] = region
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ModelManager', request='DestroyModels', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='ModelManager', request='DestroyModels', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~MapResult]<~MapResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ModelManager', request='DumpModels', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='ModelManager', request='DumpModels', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~MapResult]<~MapResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ModelManager', request='DumpModelsDB', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='ModelManager', request='DumpModelsDB', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~UserModel]<~UserModel>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ModelManager', request='ListModels', version=2, params=params)
- params['tag'] = tag
+ _params = dict()
+ msg = dict(type='ModelManager', request='ListModels', version=2, params=_params)
+ _params['tag'] = tag
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ModelDefaultsResult)
+ async def ModelDefaults(self):
+ '''
+
+ Returns -> typing.Mapping<~KT, +VT_co>[str, ~ModelDefaults]<~ModelDefaults>
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='ModelManager', request='ModelDefaults', version=2, params=_params)
+
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ModelInfoResult]<~ModelInfoResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ModelManager', request='ModelInfo', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='ModelManager', request='ModelInfo', version=2, params=_params)
+ _params['entities'] = entities
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ModelStatusResults)
+ async def ModelStatus(self, entities):
+ '''
+ entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+ Returns -> typing.Sequence<+T_co>[~ModelStatus]<~ModelStatus>
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='ModelManager', request='ModelStatus', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ModelManager', request='ModifyModelAccess', version=2, params=params)
- params['changes'] = changes
+ _params = dict()
+ msg = dict(type='ModelManager', request='ModifyModelAccess', version=2, params=_params)
+ _params['changes'] = changes
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ErrorResults)
+ async def SetModelDefaults(self, config):
+ '''
+ config : typing.Sequence<+T_co>[~ModelDefaultValues]<~ModelDefaultValues>
+ Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='ModelManager', request='SetModelDefaults', version=2, params=_params)
+ _params['config'] = config
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ErrorResults)
+ async def UnsetModelDefaults(self, keys):
+ '''
+ keys : typing.Sequence<+T_co>[~ModelUnsetKeys]<~ModelUnsetKeys>
+ Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='ModelManager', request='UnsetModelDefaults', version=2, params=_params)
+ _params['keys'] = keys
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='NotifyWatcher', request='Next', version=1, params=params)
+ _params = dict()
+ msg = dict(type='NotifyWatcher', request='Next', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='NotifyWatcher', request='Stop', version=1, params=params)
+ _params = dict()
+ msg = dict(type='NotifyWatcher', request='Stop', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Pinger', request='Ping', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Pinger', request='Ping', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Pinger', request='Stop', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Pinger', request='Stop', version=1, params=_params)
reply = await self.rpc(msg)
return reply
'Value': {'additionalProperties': False,
'properties': {'arch': {'type': 'string'},
'container': {'type': 'string'},
- 'cpu-cores': {'type': 'integer'},
+ 'cores': {'type': 'integer'},
'cpu-power': {'type': 'integer'},
'instance-type': {'type': 'string'},
'mem': {'type': 'integer'},
Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence<+T_co>[str]]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='APIAddresses', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='APIAddresses', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~HostPort]<~HostPort>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='APIHostPorts', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='APIHostPorts', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[int]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='CACert', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='CACert', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ConstraintsResult]<~ConstraintsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='Constraints', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='Constraints', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('UpdateBehavior'), str, _ForwardRef('Settings'), _ForwardRef('Settings'), bool]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='ContainerConfig', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='ContainerConfig', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='ContainerManagerConfig', version=3, params=params)
- params['type'] = type_
+ _params = dict()
+ msg = dict(type='Provisioner', request='ContainerManagerConfig', version=3, params=_params)
+ _params['type'] = type_
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='ControllerConfig', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='ControllerConfig', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~DistributionGroupResult]<~DistributionGroupResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='DistributionGroup', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='DistributionGroup', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='EnsureDead', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='EnsureDead', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence<+T_co>[~Tools]<~Tools>]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='FindTools', version=3, params=params)
- params['arch'] = arch
- params['major'] = major
- params['minor'] = minor
- params['number'] = number
- params['series'] = series
+ _params = dict()
+ msg = dict(type='Provisioner', request='FindTools', version=3, params=_params)
+ _params['arch'] = arch
+ _params['major'] = major
+ _params['minor'] = minor
+ _params['number'] = number
+ _params['series'] = series
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~MachineNetworkConfigResult]<~MachineNetworkConfigResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='GetContainerInterfaceInfo', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='GetContainerInterfaceInfo', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='InstanceId', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='InstanceId', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='InstanceStatus', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='InstanceStatus', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='Life', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='Life', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='MachinesWithTransientErrors', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='MachinesWithTransientErrors', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='MarkMachinesForRemoval', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='MarkMachinesForRemoval', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='ModelConfig', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='ModelConfig', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='ModelUUID', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='ModelUUID', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~MachineNetworkConfigResult]<~MachineNetworkConfigResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='PrepareContainerInterfaceInfo', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='PrepareContainerInterfaceInfo', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ProvisioningInfoResult]<~ProvisioningInfoResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='ProvisioningInfo', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='ProvisioningInfo', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='ReleaseContainerAddresses', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='ReleaseContainerAddresses', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='Remove', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='Remove', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='Series', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='Series', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='SetInstanceInfo', version=3, params=params)
- params['machines'] = machines
+ _params = dict()
+ msg = dict(type='Provisioner', request='SetInstanceInfo', version=3, params=_params)
+ _params['machines'] = machines
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='SetInstanceStatus', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='SetInstanceStatus', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='SetPasswords', version=3, params=params)
- params['changes'] = changes
+ _params = dict()
+ msg = dict(type='Provisioner', request='SetPasswords', version=3, params=_params)
+ _params['changes'] = changes
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='SetStatus', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='SetStatus', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='SetSupportedContainers', version=3, params=params)
- params['params'] = params
+ _params = dict()
+ msg = dict(type='Provisioner', request='SetSupportedContainers', version=3, params=_params)
+ _params['params'] = params
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence<+T_co>[str]]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='StateAddresses', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='StateAddresses', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='Status', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='Status', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ToolsResult]<~ToolsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='Tools', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='Tools', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='UpdateStatus', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Provisioner', request='UpdateStatus', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='WatchAPIHostPorts', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='WatchAPIHostPorts', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='WatchAllContainers', version=3, params=params)
- params['params'] = params
+ _params = dict()
+ msg = dict(type='Provisioner', request='WatchAllContainers', version=3, params=_params)
+ _params['params'] = params
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='WatchContainers', version=3, params=params)
- params['params'] = params
+ _params = dict()
+ msg = dict(type='Provisioner', request='WatchContainers', version=3, params=_params)
+ _params['params'] = params
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='WatchForModelConfigChanges', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='WatchForModelConfigChanges', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='WatchMachineErrorRetry', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='WatchMachineErrorRetry', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[typing.Sequence<+T_co>[str], _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Provisioner', request='WatchModelMachines', version=3, params=params)
+ _params = dict()
+ msg = dict(type='Provisioner', request='WatchModelMachines', version=3, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ProxyConfigResult]<~ProxyConfigResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ProxyUpdater', request='ProxyConfig', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='ProxyUpdater', request='ProxyConfig', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='ProxyUpdater', request='WatchForProxyConfigAndAPIHostPortChanges', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='ProxyUpdater', request='WatchForProxyConfigAndAPIHostPortChanges', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Reboot', request='ClearReboot', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Reboot', request='ClearReboot', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~RebootActionResult]<~RebootActionResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Reboot', request='GetRebootAction', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Reboot', request='GetRebootAction', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Reboot', request='RequestReboot', version=2, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Reboot', request='RequestReboot', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Reboot', request='WatchForRebootEvent', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Reboot', request='WatchForRebootEvent', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('RelationUnitsChange'), _ForwardRef('Error'), str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='RelationUnitsWatcher', request='Next', version=1, params=params)
+ _params = dict()
+ msg = dict(type='RelationUnitsWatcher', request='Next', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='RelationUnitsWatcher', request='Stop', version=1, params=params)
+ _params = dict()
+ msg = dict(type='RelationUnitsWatcher', request='Stop', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Resumer', request='ResumeTransactions', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Resumer', request='ResumeTransactions', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~RetryStrategyResult]<~RetryStrategyResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='RetryStrategy', request='RetryStrategy', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='RetryStrategy', request='RetryStrategy', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='RetryStrategy', request='WatchRetryStrategy', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='RetryStrategy', request='WatchRetryStrategy', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
class SSHClientFacade(Type):
name = 'SSHClient'
- version = 1
+ version = 2
schema = {'definitions': {'Entities': {'additionalProperties': False,
'properties': {'entities': {'items': {'$ref': '#/definitions/Entity'},
'type': 'array'}},
'type': 'array'}},
'required': ['results'],
'type': 'object'},
+ 'SSHAddressesResult': {'additionalProperties': False,
+ 'properties': {'addresses': {'items': {'type': 'string'},
+ 'type': 'array'},
+ 'error': {'$ref': '#/definitions/Error'}},
+ 'required': ['addresses'],
+ 'type': 'object'},
+ 'SSHAddressesResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/SSHAddressesResult'},
+ 'type': 'array'}},
+ 'required': ['results'],
+ 'type': 'object'},
'SSHProxyResult': {'additionalProperties': False,
'properties': {'use-proxy': {'type': 'boolean'}},
'required': ['use-proxy'],
'type': 'array'}},
'required': ['results'],
'type': 'object'}},
- 'properties': {'PrivateAddress': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'properties': {'AllAddresses': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/SSHAddressesResults'}},
+ 'type': 'object'},
+ 'PrivateAddress': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
'Result': {'$ref': '#/definitions/SSHAddressResults'}},
'type': 'object'},
'Proxy': {'properties': {'Result': {'$ref': '#/definitions/SSHProxyResult'}},
'type': 'object'}
+ @ReturnMapping(SSHAddressesResults)
+ async def AllAddresses(self, entities):
+ '''
+ entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+ Returns -> typing.Sequence<+T_co>[~SSHAddressesResult]<~SSHAddressesResult>
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='SSHClient', request='AllAddresses', version=2, params=_params)
+ _params['entities'] = entities
+ reply = await self.rpc(msg)
+ return reply
+
+
+
@ReturnMapping(SSHAddressResults)
async def PrivateAddress(self, entities):
'''
Returns -> typing.Sequence<+T_co>[~SSHAddressResult]<~SSHAddressResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='SSHClient', request='PrivateAddress', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='SSHClient', request='PrivateAddress', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> bool
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='SSHClient', request='Proxy', version=1, params=params)
+ _params = dict()
+ msg = dict(type='SSHClient', request='Proxy', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~SSHAddressResult]<~SSHAddressResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='SSHClient', request='PublicAddress', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='SSHClient', request='PublicAddress', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~SSHPublicKeysResult]<~SSHPublicKeysResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='SSHClient', request='PublicKeys', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='SSHClient', request='PublicKeys', version=2, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Singular', request='Claim', version=1, params=params)
- params['claims'] = claims
+ _params = dict()
+ msg = dict(type='Singular', request='Claim', version=1, params=_params)
+ _params['claims'] = claims
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Singular', request='Wait', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Singular', request='Wait', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Spaces', request='CreateSpaces', version=2, params=params)
- params['spaces'] = spaces
+ _params = dict()
+ msg = dict(type='Spaces', request='CreateSpaces', version=2, params=_params)
+ _params['spaces'] = spaces
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~Space]<~Space>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Spaces', request='ListSpaces', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Spaces', request='ListSpaces', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StatusHistory', request='Prune', version=2, params=params)
- params['max-history-mb'] = max_history_mb
- params['max-history-time'] = max_history_time
+ _params = dict()
+ msg = dict(type='StatusHistory', request='Prune', version=2, params=_params)
+ _params['max-history-mb'] = max_history_mb
+ _params['max-history-time'] = max_history_time
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Storage', request='AddToUnit', version=3, params=params)
- params['storages'] = storages
+ _params = dict()
+ msg = dict(type='Storage', request='AddToUnit', version=3, params=_params)
+ _params['storages'] = storages
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Storage', request='CreatePool', version=3, params=params)
- params['attrs'] = attrs
- params['name'] = name
- params['provider'] = provider
+ _params = dict()
+ msg = dict(type='Storage', request='CreatePool', version=3, params=_params)
+ _params['attrs'] = attrs
+ _params['name'] = name
+ _params['provider'] = provider
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~FilesystemDetailsListResult]<~FilesystemDetailsListResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Storage', request='ListFilesystems', version=3, params=params)
- params['filters'] = filters
+ _params = dict()
+ msg = dict(type='Storage', request='ListFilesystems', version=3, params=_params)
+ _params['filters'] = filters
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StoragePoolsResult]<~StoragePoolsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Storage', request='ListPools', version=3, params=params)
- params['filters'] = filters
+ _params = dict()
+ msg = dict(type='Storage', request='ListPools', version=3, params=_params)
+ _params['filters'] = filters
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StorageDetailsListResult]<~StorageDetailsListResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Storage', request='ListStorageDetails', version=3, params=params)
- params['filters'] = filters
+ _params = dict()
+ msg = dict(type='Storage', request='ListStorageDetails', version=3, params=_params)
+ _params['filters'] = filters
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~VolumeDetailsListResult]<~VolumeDetailsListResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Storage', request='ListVolumes', version=3, params=params)
- params['filters'] = filters
+ _params = dict()
+ msg = dict(type='Storage', request='ListVolumes', version=3, params=_params)
+ _params['filters'] = filters
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StorageDetailsResult]<~StorageDetailsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Storage', request='StorageDetails', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Storage', request='StorageDetails', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='AttachmentLife', version=3, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='AttachmentLife', version=3, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='EnsureDead', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='EnsureDead', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~FilesystemAttachmentParamsResult]<~FilesystemAttachmentParamsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='FilesystemAttachmentParams', version=3, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='FilesystemAttachmentParams', version=3, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~FilesystemAttachmentResult]<~FilesystemAttachmentResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='FilesystemAttachments', version=3, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='FilesystemAttachments', version=3, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~FilesystemParamsResult]<~FilesystemParamsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='FilesystemParams', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='FilesystemParams', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~FilesystemResult]<~FilesystemResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='Filesystems', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='Filesystems', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='InstanceId', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='InstanceId', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='Life', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='Life', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='Remove', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='Remove', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='RemoveAttachment', version=3, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='RemoveAttachment', version=3, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='SetFilesystemAttachmentInfo', version=3, params=params)
- params['filesystem-attachments'] = filesystem_attachments
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='SetFilesystemAttachmentInfo', version=3, params=_params)
+ _params['filesystem-attachments'] = filesystem_attachments
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='SetFilesystemInfo', version=3, params=params)
- params['filesystems'] = filesystems
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='SetFilesystemInfo', version=3, params=_params)
+ _params['filesystems'] = filesystems
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='SetStatus', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='SetStatus', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='SetVolumeAttachmentInfo', version=3, params=params)
- params['volume-attachments'] = volume_attachments
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='SetVolumeAttachmentInfo', version=3, params=_params)
+ _params['volume-attachments'] = volume_attachments
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='SetVolumeInfo', version=3, params=params)
- params['volumes'] = volumes
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='SetVolumeInfo', version=3, params=_params)
+ _params['volumes'] = volumes
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='UpdateStatus', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='UpdateStatus', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~VolumeAttachmentParamsResult]<~VolumeAttachmentParamsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='VolumeAttachmentParams', version=3, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='VolumeAttachmentParams', version=3, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~VolumeAttachmentResult]<~VolumeAttachmentResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='VolumeAttachments', version=3, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='VolumeAttachments', version=3, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~BlockDeviceResult]<~BlockDeviceResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='VolumeBlockDevices', version=3, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='VolumeBlockDevices', version=3, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~VolumeParamsResult]<~VolumeParamsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='VolumeParams', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='VolumeParams', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~VolumeResult]<~VolumeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='Volumes', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='Volumes', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='WatchBlockDevices', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='WatchBlockDevices', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~MachineStorageIdsWatchResult]<~MachineStorageIdsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='WatchFilesystemAttachments', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='WatchFilesystemAttachments', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='WatchFilesystems', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='WatchFilesystems', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='WatchMachines', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='WatchMachines', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~MachineStorageIdsWatchResult]<~MachineStorageIdsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='WatchVolumeAttachments', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='WatchVolumeAttachments', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StorageProvisioner', request='WatchVolumes', version=3, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='StorageProvisioner', request='WatchVolumes', version=3, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[typing.Sequence<+T_co>[str], _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StringsWatcher', request='Next', version=1, params=params)
+ _params = dict()
+ msg = dict(type='StringsWatcher', request='Next', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='StringsWatcher', request='Stop', version=1, params=params)
+ _params = dict()
+ msg = dict(type='StringsWatcher', request='Stop', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Subnets', request='AddSubnets', version=2, params=params)
- params['subnets'] = subnets
+ _params = dict()
+ msg = dict(type='Subnets', request='AddSubnets', version=2, params=_params)
+ _params['subnets'] = subnets
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~SpaceResult]<~SpaceResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Subnets', request='AllSpaces', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Subnets', request='AllSpaces', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ZoneResult]<~ZoneResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Subnets', request='AllZones', version=2, params=params)
+ _params = dict()
+ msg = dict(type='Subnets', request='AllZones', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~Subnet]<~Subnet>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Subnets', request='ListSubnets', version=2, params=params)
- params['space-tag'] = space_tag
- params['zone'] = zone
+ _params = dict()
+ msg = dict(type='Subnets', request='ListSubnets', version=2, params=_params)
+ _params['space-tag'] = space_tag
+ _params['zone'] = zone
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Undertaker', request='ModelConfig', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Undertaker', request='ModelConfig', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), _ForwardRef('UndertakerModelInfo')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Undertaker', request='ModelInfo', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Undertaker', request='ModelInfo', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Undertaker', request='ProcessDyingModel', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Undertaker', request='ProcessDyingModel', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Undertaker', request='RemoveModel', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Undertaker', request='RemoveModel', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Undertaker', request='SetStatus', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Undertaker', request='SetStatus', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Undertaker', request='UpdateStatus', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Undertaker', request='UpdateStatus', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Undertaker', request='WatchModelResources', version=1, params=params)
+ _params = dict()
+ msg = dict(type='Undertaker', request='WatchModelResources', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='UnitAssigner', request='AssignUnits', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='UnitAssigner', request='AssignUnits', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='UnitAssigner', request='SetAgentStatus', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='UnitAssigner', request='SetAgentStatus', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[typing.Sequence<+T_co>[str], _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='UnitAssigner', request='WatchUnitAssignments', version=1, params=params)
+ _params = dict()
+ msg = dict(type='UnitAssigner', request='WatchUnitAssignments', version=1, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence<+T_co>[str]]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='APIAddresses', version=4, params=params)
+ _params = dict()
+ msg = dict(type='Uniter', request='APIAddresses', version=4, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~HostPort]<~HostPort>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='APIHostPorts', version=4, params=params)
+ _params = dict()
+ msg = dict(type='Uniter', request='APIHostPorts', version=4, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='Actions', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='Actions', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='AddMetricBatches', version=4, params=params)
- params['batches'] = batches
+ _params = dict()
+ msg = dict(type='Uniter', request='AddMetricBatches', version=4, params=_params)
+ _params['batches'] = batches
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='AddUnitStorage', version=4, params=params)
- params['storages'] = storages
+ _params = dict()
+ msg = dict(type='Uniter', request='AddUnitStorage', version=4, params=_params)
+ _params['storages'] = storages
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~MachinePortsResult]<~MachinePortsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='AllMachinePorts', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='AllMachinePorts', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ApplicationStatusResult]<~ApplicationStatusResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='ApplicationStatus', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='ApplicationStatus', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='AssignedMachine', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='AssignedMachine', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='AvailabilityZone', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='AvailabilityZone', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='BeginActions', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='BeginActions', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[int]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='CACert', version=4, params=params)
+ _params = dict()
+ msg = dict(type='Uniter', request='CACert', version=4, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='CharmArchiveSha256', version=4, params=params)
- params['urls'] = urls
+ _params = dict()
+ msg = dict(type='Uniter', request='CharmArchiveSha256', version=4, params=_params)
+ _params['urls'] = urls
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~IntResult]<~IntResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='CharmModifiedVersion', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='CharmModifiedVersion', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringBoolResult]<~StringBoolResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='CharmURL', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='CharmURL', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='ClearResolved', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='ClearResolved', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='ClosePorts', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='ClosePorts', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ConfigSettingsResult]<~ConfigSettingsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='ConfigSettings', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='ConfigSettings', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='CurrentModel', version=4, params=params)
+ _params = dict()
+ msg = dict(type='Uniter', request='CurrentModel', version=4, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='Destroy', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='Destroy', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='DestroyAllSubordinates', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='DestroyAllSubordinates', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='DestroyUnitStorageAttachments', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='DestroyUnitStorageAttachments', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='EnsureDead', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='EnsureDead', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='EnterScope', version=4, params=params)
- params['relation-units'] = relation_units
+ _params = dict()
+ msg = dict(type='Uniter', request='EnterScope', version=4, params=_params)
+ _params['relation-units'] = relation_units
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='FinishActions', version=4, params=params)
- params['results'] = results
+ _params = dict()
+ msg = dict(type='Uniter', request='FinishActions', version=4, params=_params)
+ _params['results'] = results
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~MeterStatusResult]<~MeterStatusResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='GetMeterStatus', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='GetMeterStatus', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringBoolResult]<~StringBoolResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='GetPrincipal', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='GetPrincipal', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~BoolResult]<~BoolResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='HasSubordinates', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='HasSubordinates', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsResult]<~StringsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='JoinedRelations', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='JoinedRelations', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='LeaveScope', version=4, params=params)
- params['relation-units'] = relation_units
+ _params = dict()
+ msg = dict(type='Uniter', request='LeaveScope', version=4, params=_params)
+ _params['relation-units'] = relation_units
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='Life', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='Life', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='Merge', version=4, params=params)
- params['params'] = params
+ _params = dict()
+ msg = dict(type='Uniter', request='Merge', version=4, params=_params)
+ _params['params'] = params
reply = await self.rpc(msg)
return reply
Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='ModelConfig', version=4, params=params)
+ _params = dict()
+ msg = dict(type='Uniter', request='ModelConfig', version=4, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='ModelUUID', version=4, params=params)
+ _params = dict()
+ msg = dict(type='Uniter', request='ModelUUID', version=4, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~UnitNetworkConfigResult]<~UnitNetworkConfigResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='NetworkConfig', version=4, params=params)
- params['args'] = args
+ _params = dict()
+ msg = dict(type='Uniter', request='NetworkConfig', version=4, params=_params)
+ _params['args'] = args
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='OpenPorts', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='OpenPorts', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='PrivateAddress', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='PrivateAddress', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[_ForwardRef('Error'), str]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='ProviderType', version=4, params=params)
+ _params = dict()
+ msg = dict(type='Uniter', request='ProviderType', version=4, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='PublicAddress', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='PublicAddress', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~GetLeadershipSettingsResult]<~GetLeadershipSettingsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='Read', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='Read', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~SettingsResult]<~SettingsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='ReadRemoteSettings', version=4, params=params)
- params['relation-unit-pairs'] = relation_unit_pairs
+ _params = dict()
+ msg = dict(type='Uniter', request='ReadRemoteSettings', version=4, params=_params)
+ _params['relation-unit-pairs'] = relation_unit_pairs
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~SettingsResult]<~SettingsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='ReadSettings', version=4, params=params)
- params['relation-units'] = relation_units
+ _params = dict()
+ msg = dict(type='Uniter', request='ReadSettings', version=4, params=_params)
+ _params['relation-units'] = relation_units
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~RelationResult]<~RelationResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='Relation', version=4, params=params)
- params['relation-units'] = relation_units
+ _params = dict()
+ msg = dict(type='Uniter', request='Relation', version=4, params=_params)
+ _params['relation-units'] = relation_units
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~RelationResult]<~RelationResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='RelationById', version=4, params=params)
- params['relation-ids'] = relation_ids
+ _params = dict()
+ msg = dict(type='Uniter', request='RelationById', version=4, params=_params)
+ _params['relation-ids'] = relation_ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='RemoveStorageAttachments', version=4, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='Uniter', request='RemoveStorageAttachments', version=4, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='RequestReboot', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='RequestReboot', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ResolvedModeResult]<~ResolvedModeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='Resolved', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='Resolved', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='SetAgentStatus', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='SetAgentStatus', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='SetApplicationStatus', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='SetApplicationStatus', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='SetCharmURL', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='SetCharmURL', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='SetStatus', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='SetStatus', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='SetUnitStatus', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='SetUnitStatus', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='SetWorkloadVersion', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='SetWorkloadVersion', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='StorageAttachmentLife', version=4, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='Uniter', request='StorageAttachmentLife', version=4, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StorageAttachmentResult]<~StorageAttachmentResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='StorageAttachments', version=4, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='Uniter', request='StorageAttachments', version=4, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='UnitStatus', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='UnitStatus', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StorageAttachmentIdsResult]<~StorageAttachmentIdsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='UnitStorageAttachments', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='UnitStorageAttachments', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='UpdateSettings', version=4, params=params)
- params['relation-units'] = relation_units
+ _params = dict()
+ msg = dict(type='Uniter', request='UpdateSettings', version=4, params=_params)
+ _params['relation-units'] = relation_units
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='Watch', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='Watch', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WatchAPIHostPorts', version=4, params=params)
+ _params = dict()
+ msg = dict(type='Uniter', request='WatchAPIHostPorts', version=4, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WatchActionNotifications', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='WatchActionNotifications', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WatchApplicationRelations', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='WatchApplicationRelations', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WatchConfigSettings', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='WatchConfigSettings', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[str, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WatchForModelConfigChanges', version=4, params=params)
+ _params = dict()
+ msg = dict(type='Uniter', request='WatchForModelConfigChanges', version=4, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WatchLeadershipSettings', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='WatchLeadershipSettings', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WatchMeterStatus', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='WatchMeterStatus', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~RelationUnitsWatchResult]<~RelationUnitsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WatchRelationUnits', version=4, params=params)
- params['relation-units'] = relation_units
+ _params = dict()
+ msg = dict(type='Uniter', request='WatchRelationUnits', version=4, params=_params)
+ _params['relation-units'] = relation_units
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WatchStorageAttachments', version=4, params=params)
- params['ids'] = ids
+ _params = dict()
+ msg = dict(type='Uniter', request='WatchStorageAttachments', version=4, params=_params)
+ _params['ids'] = ids
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WatchUnitAddresses', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='WatchUnitAddresses', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WatchUnitStorageAttachments', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='WatchUnitStorageAttachments', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Uniter', request='WorkloadVersion', version=4, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Uniter', request='WorkloadVersion', version=4, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~VersionResult]<~VersionResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Upgrader', request='DesiredVersion', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Upgrader', request='DesiredVersion', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Upgrader', request='SetTools', version=1, params=params)
- params['agent-tools'] = agent_tools
+ _params = dict()
+ msg = dict(type='Upgrader', request='SetTools', version=1, params=_params)
+ _params['agent-tools'] = agent_tools
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ToolsResult]<~ToolsResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Upgrader', request='Tools', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Upgrader', request='Tools', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='Upgrader', request='WatchAPIVersion', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='Upgrader', request='WatchAPIVersion', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
'required': ['results'],
'type': 'object'},
'Macaroon': {'additionalProperties': False, 'type': 'object'},
- 'MacaroonResult': {'additionalProperties': False,
- 'properties': {'error': {'$ref': '#/definitions/Error'},
- 'result': {'$ref': '#/definitions/Macaroon'}},
- 'type': 'object'},
- 'MacaroonResults': {'additionalProperties': False,
- 'properties': {'results': {'items': {'$ref': '#/definitions/MacaroonResult'},
- 'type': 'array'}},
- 'required': ['results'],
- 'type': 'object'},
'UserInfo': {'additionalProperties': False,
'properties': {'access': {'type': 'string'},
'created-by': {'type': 'string'},
'properties': {'AddUser': {'properties': {'Params': {'$ref': '#/definitions/AddUsers'},
'Result': {'$ref': '#/definitions/AddUserResults'}},
'type': 'object'},
- 'CreateLocalLoginMacaroon': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
- 'Result': {'$ref': '#/definitions/MacaroonResults'}},
- 'type': 'object'},
'DisableUser': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
'Result': {'$ref': '#/definitions/ErrorResults'}},
'type': 'object'},
Returns -> typing.Sequence<+T_co>[~AddUserResult]<~AddUserResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='UserManager', request='AddUser', version=1, params=params)
- params['users'] = users
- reply = await self.rpc(msg)
- return reply
-
-
-
- @ReturnMapping(MacaroonResults)
- async def CreateLocalLoginMacaroon(self, entities):
- '''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~MacaroonResult]<~MacaroonResult>
- '''
- # map input types to rpc msg
- params = dict()
- msg = dict(type='UserManager', request='CreateLocalLoginMacaroon', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='UserManager', request='AddUser', version=1, params=_params)
+ _params['users'] = users
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='UserManager', request='DisableUser', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='UserManager', request='DisableUser', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='UserManager', request='EnableUser', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='UserManager', request='EnableUser', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='UserManager', request='RemoveUser', version=1, params=params)
- params['entities'] = entities
+ _params = dict()
+ msg = dict(type='UserManager', request='RemoveUser', version=1, params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='UserManager', request='SetPassword', version=1, params=params)
- params['changes'] = changes
+ _params = dict()
+ msg = dict(type='UserManager', request='SetPassword', version=1, params=_params)
+ _params['changes'] = changes
reply = await self.rpc(msg)
return reply
Returns -> typing.Sequence<+T_co>[~UserInfoResult]<~UserInfoResult>
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='UserManager', request='UserInfo', version=1, params=params)
- params['entities'] = entities
- params['include-disabled'] = include_disabled
+ _params = dict()
+ msg = dict(type='UserManager', request='UserInfo', version=1, params=_params)
+ _params['entities'] = entities
+ _params['include-disabled'] = include_disabled
reply = await self.rpc(msg)
return reply
Returns -> typing.Union[typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>, _ForwardRef('Error')]
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='VolumeAttachmentsWatcher', request='Next', version=2, params=params)
+ _params = dict()
+ msg = dict(type='VolumeAttachmentsWatcher', request='Next', version=2, params=_params)
reply = await self.rpc(msg)
return reply
Returns -> None
'''
# map input types to rpc msg
- params = dict()
- msg = dict(type='VolumeAttachmentsWatcher', request='Stop', version=2, params=params)
+ _params = dict()
+ msg = dict(type='VolumeAttachmentsWatcher', request='Stop', version=2, params=_params)
reply = await self.rpc(msg)
return reply
projects / osm / N2VC.git / blobdiff