from juju.client.facade import ReturnMapping, Type
+class ActionFacade(Type):
+ name = 'Action'
+ version = 3
+ schema = {'definitions': {'Action': {'additionalProperties': False,
+ 'properties': {'name': {'type': 'string'},
+ 'parameters': {'patternProperties': {'.*': {'additionalProperties': True,
+ 'type': 'object'}},
+ 'type': 'object'},
+ 'receiver': {'type': 'string'},
+ 'tag': {'type': 'string'}},
+ 'required': ['tag', 'receiver', 'name'],
+ 'type': 'object'},
+ 'ActionResult': {'additionalProperties': False,
+ 'properties': {'action': {'$ref': '#/definitions/Action'},
+ 'completed': {'format': 'date-time',
+ 'type': 'string'},
+ 'enqueued': {'format': 'date-time',
+ 'type': 'string'},
+ 'error': {'$ref': '#/definitions/Error'},
+ 'message': {'type': 'string'},
+ 'output': {'patternProperties': {'.*': {'additionalProperties': True,
+ 'type': 'object'}},
+ 'type': 'object'},
+ 'started': {'format': 'date-time',
+ 'type': 'string'},
+ 'status': {'type': 'string'}},
+ 'type': 'object'},
+ 'ActionResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/ActionResult'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'ActionSpec': {'additionalProperties': False,
+ 'properties': {'description': {'type': 'string'},
+ 'params': {'patternProperties': {'.*': {'additionalProperties': True,
+ 'type': 'object'}},
+ 'type': 'object'}},
+ 'required': ['description', 'params'],
+ 'type': 'object'},
+ 'Actions': {'additionalProperties': False,
+ 'properties': {'actions': {'items': {'$ref': '#/definitions/Action'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'ActionsByName': {'additionalProperties': False,
+ 'properties': {'actions': {'items': {'$ref': '#/definitions/ActionResult'},
+ 'type': 'array'},
+ 'error': {'$ref': '#/definitions/Error'},
+ 'name': {'type': 'string'}},
+ 'type': 'object'},
+ 'ActionsByNames': {'additionalProperties': False,
+ 'properties': {'actions': {'items': {'$ref': '#/definitions/ActionsByName'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'ActionsByReceiver': {'additionalProperties': False,
+ 'properties': {'actions': {'items': {'$ref': '#/definitions/ActionResult'},
+ 'type': 'array'},
+ 'error': {'$ref': '#/definitions/Error'},
+ 'receiver': {'type': 'string'}},
+ 'type': 'object'},
+ 'ActionsByReceivers': {'additionalProperties': False,
+ 'properties': {'actions': {'items': {'$ref': '#/definitions/ActionsByReceiver'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'ApplicationCharmActionsResult': {'additionalProperties': False,
+ 'properties': {'actions': {'patternProperties': {'.*': {'$ref': '#/definitions/ActionSpec'}},
+ 'type': 'object'},
+ 'application-tag': {'type': 'string'},
+ 'error': {'$ref': '#/definitions/Error'}},
+ 'type': 'object'},
+ 'ApplicationsCharmActionsResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/ApplicationCharmActionsResult'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'Entities': {'additionalProperties': False,
+ 'properties': {'entities': {'items': {'$ref': '#/definitions/Entity'},
+ 'type': 'array'}},
+ 'required': ['entities'],
+ 'type': 'object'},
+ 'Entity': {'additionalProperties': False,
+ 'properties': {'tag': {'type': 'string'}},
+ 'required': ['tag'],
+ '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'},
+ 'FindActionsByNames': {'additionalProperties': False,
+ 'properties': {'names': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'FindTags': {'additionalProperties': False,
+ 'properties': {'prefixes': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'required': ['prefixes'],
+ 'type': 'object'},
+ 'FindTagsResults': {'additionalProperties': False,
+ 'properties': {'matches': {'patternProperties': {'.*': {'items': {'$ref': '#/definitions/Entity'},
+ 'type': 'array'}},
+ 'type': 'object'}},
+ 'required': ['matches'],
+ 'type': 'object'},
+ 'Macaroon': {'additionalProperties': False, 'type': 'object'},
+ 'RunParams': {'additionalProperties': False,
+ 'properties': {'applications': {'items': {'type': 'string'},
+ 'type': 'array'},
+ 'commands': {'type': 'string'},
+ 'machines': {'items': {'type': 'string'},
+ 'type': 'array'},
+ 'timeout': {'type': 'integer'},
+ 'units': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'required': ['commands', 'timeout'],
+ 'type': 'object'}},
+ 'properties': {'Actions': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/ActionResults'}},
+ 'type': 'object'},
+ 'ApplicationsCharmsActions': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/ApplicationsCharmActionsResults'}},
+ 'type': 'object'},
+ 'Cancel': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/ActionResults'}},
+ 'type': 'object'},
+ 'Enqueue': {'properties': {'Params': {'$ref': '#/definitions/Actions'},
+ 'Result': {'$ref': '#/definitions/ActionResults'}},
+ 'type': 'object'},
+ 'FindActionTagsByPrefix': {'properties': {'Params': {'$ref': '#/definitions/FindTags'},
+ 'Result': {'$ref': '#/definitions/FindTagsResults'}},
+ 'type': 'object'},
+ 'FindActionsByNames': {'properties': {'Params': {'$ref': '#/definitions/FindActionsByNames'},
+ 'Result': {'$ref': '#/definitions/ActionsByNames'}},
+ 'type': 'object'},
+ 'ListAll': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/ActionsByReceivers'}},
+ 'type': 'object'},
+ 'ListCompleted': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/ActionsByReceivers'}},
+ 'type': 'object'},
+ 'ListPending': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/ActionsByReceivers'}},
+ 'type': 'object'},
+ 'ListRunning': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/ActionsByReceivers'}},
+ 'type': 'object'},
+ 'Run': {'properties': {'Params': {'$ref': '#/definitions/RunParams'},
+ 'Result': {'$ref': '#/definitions/ActionResults'}},
+ 'type': 'object'},
+ 'RunOnAllMachines': {'properties': {'Params': {'$ref': '#/definitions/RunParams'},
+ 'Result': {'$ref': '#/definitions/ActionResults'}},
+ 'type': 'object'}},
+ 'type': 'object'}
+
+
+ @ReturnMapping(ActionResults)
+ async def Actions(self, entities):
+ '''
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ActionResult]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='Actions',
+ version=3,
+ params=_params)
+ _params['entities'] = entities
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ApplicationsCharmActionsResults)
+ async def ApplicationsCharmsActions(self, entities):
+ '''
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ApplicationCharmActionsResult]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='ApplicationsCharmsActions',
+ version=3,
+ params=_params)
+ _params['entities'] = entities
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ActionResults)
+ async def Cancel(self, entities):
+ '''
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ActionResult]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='Cancel',
+ version=3,
+ params=_params)
+ _params['entities'] = entities
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ActionResults)
+ async def Enqueue(self, actions):
+ '''
+ actions : typing.Sequence[~Action]
+ Returns -> typing.Sequence[~ActionResult]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='Enqueue',
+ version=3,
+ params=_params)
+ _params['actions'] = actions
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(FindTagsResults)
+ async def FindActionTagsByPrefix(self, prefixes):
+ '''
+ prefixes : typing.Sequence[str]
+ Returns -> typing.Sequence[~Entity]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='FindActionTagsByPrefix',
+ version=3,
+ params=_params)
+ _params['prefixes'] = prefixes
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ActionsByNames)
+ async def FindActionsByNames(self, names):
+ '''
+ names : typing.Sequence[str]
+ Returns -> typing.Sequence[~ActionsByName]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='FindActionsByNames',
+ version=3,
+ params=_params)
+ _params['names'] = names
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ActionsByReceivers)
+ async def ListAll(self, entities):
+ '''
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ActionsByReceiver]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='ListAll',
+ version=3,
+ params=_params)
+ _params['entities'] = entities
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ActionsByReceivers)
+ async def ListCompleted(self, entities):
+ '''
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ActionsByReceiver]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='ListCompleted',
+ version=3,
+ params=_params)
+ _params['entities'] = entities
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ActionsByReceivers)
+ async def ListPending(self, entities):
+ '''
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ActionsByReceiver]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='ListPending',
+ version=3,
+ params=_params)
+ _params['entities'] = entities
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ActionsByReceivers)
+ async def ListRunning(self, entities):
+ '''
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ActionsByReceiver]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='ListRunning',
+ version=3,
+ params=_params)
+ _params['entities'] = entities
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ActionResults)
+ async def Run(self, applications, commands, machines, timeout, units):
+ '''
+ applications : typing.Sequence[str]
+ commands : str
+ machines : typing.Sequence[str]
+ timeout : int
+ units : typing.Sequence[str]
+ Returns -> typing.Sequence[~ActionResult]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='Run',
+ version=3,
+ params=_params)
+ _params['applications'] = applications
+ _params['commands'] = commands
+ _params['machines'] = machines
+ _params['timeout'] = timeout
+ _params['units'] = units
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ActionResults)
+ async def RunOnAllMachines(self, applications, commands, machines, timeout, units):
+ '''
+ applications : typing.Sequence[str]
+ commands : str
+ machines : typing.Sequence[str]
+ timeout : int
+ units : typing.Sequence[str]
+ Returns -> typing.Sequence[~ActionResult]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Action',
+ request='RunOnAllMachines',
+ version=3,
+ params=_params)
+ _params['applications'] = applications
+ _params['commands'] = commands
+ _params['machines'] = machines
+ _params['timeout'] = timeout
+ _params['units'] = units
+ reply = await self.rpc(msg)
+ return reply
+
+
+
class ApplicationFacade(Type):
name = 'Application'
version = 3
'type': 'array'},
'tags': {'items': {'type': 'string'},
'type': 'array'},
- 'virt-type': {'type': 'string'}},
+ 'virt-type': {'type': 'string'}},
+ 'type': 'object'}},
+ 'properties': {'AddRelation': {'properties': {'Params': {'$ref': '#/definitions/AddRelation'},
+ 'Result': {'$ref': '#/definitions/AddRelationResults'}},
+ 'type': 'object'},
+ 'AddUnits': {'properties': {'Params': {'$ref': '#/definitions/AddApplicationUnits'},
+ 'Result': {'$ref': '#/definitions/AddApplicationUnitsResults'}},
+ 'type': 'object'},
+ 'CharmRelations': {'properties': {'Params': {'$ref': '#/definitions/ApplicationCharmRelations'},
+ 'Result': {'$ref': '#/definitions/ApplicationCharmRelationsResults'}},
+ 'type': 'object'},
+ 'Deploy': {'properties': {'Params': {'$ref': '#/definitions/ApplicationsDeploy'},
+ 'Result': {'$ref': '#/definitions/ErrorResults'}},
+ 'type': 'object'},
+ 'Destroy': {'properties': {'Params': {'$ref': '#/definitions/ApplicationDestroy'}},
+ 'type': 'object'},
+ 'DestroyRelation': {'properties': {'Params': {'$ref': '#/definitions/DestroyRelation'}},
+ 'type': 'object'},
+ 'DestroyUnits': {'properties': {'Params': {'$ref': '#/definitions/DestroyApplicationUnits'}},
+ 'type': 'object'},
+ 'Expose': {'properties': {'Params': {'$ref': '#/definitions/ApplicationExpose'}},
+ 'type': 'object'},
+ 'Get': {'properties': {'Params': {'$ref': '#/definitions/ApplicationGet'},
+ 'Result': {'$ref': '#/definitions/ApplicationGetResults'}},
+ 'type': 'object'},
+ 'GetCharmURL': {'properties': {'Params': {'$ref': '#/definitions/ApplicationGet'},
+ 'Result': {'$ref': '#/definitions/StringResult'}},
+ 'type': 'object'},
+ 'GetConstraints': {'properties': {'Params': {'$ref': '#/definitions/GetApplicationConstraints'},
+ 'Result': {'$ref': '#/definitions/GetConstraintsResults'}},
+ 'type': 'object'},
+ 'Set': {'properties': {'Params': {'$ref': '#/definitions/ApplicationSet'}},
+ 'type': 'object'},
+ 'SetCharm': {'properties': {'Params': {'$ref': '#/definitions/ApplicationSetCharm'}},
+ 'type': 'object'},
+ 'SetConstraints': {'properties': {'Params': {'$ref': '#/definitions/SetConstraints'}},
+ 'type': 'object'},
+ 'SetMetricCredentials': {'properties': {'Params': {'$ref': '#/definitions/ApplicationMetricCredentials'},
+ 'Result': {'$ref': '#/definitions/ErrorResults'}},
+ 'type': 'object'},
+ 'Unexpose': {'properties': {'Params': {'$ref': '#/definitions/ApplicationUnexpose'}},
+ 'type': 'object'},
+ 'Unset': {'properties': {'Params': {'$ref': '#/definitions/ApplicationUnset'}},
+ 'type': 'object'},
+ 'Update': {'properties': {'Params': {'$ref': '#/definitions/ApplicationUpdate'}},
+ 'type': 'object'}},
+ 'type': 'object'}
+
+
+ @ReturnMapping(AddRelationResults)
+ async def AddRelation(self, endpoints):
+ '''
+ endpoints : typing.Sequence[str]
+ Returns -> typing.Mapping[str, ~CharmRelation]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='AddRelation',
+ version=3,
+ params=_params)
+ _params['endpoints'] = endpoints
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(AddApplicationUnitsResults)
+ async def AddUnits(self, application, num_units, placement):
+ '''
+ application : str
+ num_units : int
+ placement : typing.Sequence[~Placement]
+ Returns -> typing.Sequence[str]
+ '''
+ # map input types to rpc msg
+ _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
+
+
+
+ @ReturnMapping(ApplicationCharmRelationsResults)
+ async def CharmRelations(self, application):
+ '''
+ application : str
+ Returns -> typing.Sequence[str]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='CharmRelations',
+ version=3,
+ params=_params)
+ _params['application'] = application
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ErrorResults)
+ async def Deploy(self, applications):
+ '''
+ applications : typing.Sequence[~ApplicationDeploy]
+ Returns -> typing.Sequence[~ErrorResult]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='Deploy',
+ version=3,
+ params=_params)
+ _params['applications'] = applications
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(None)
+ async def Destroy(self, application):
+ '''
+ application : str
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='Destroy',
+ version=3,
+ params=_params)
+ _params['application'] = application
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(None)
+ async def DestroyRelation(self, endpoints):
+ '''
+ endpoints : typing.Sequence[str]
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='DestroyRelation',
+ version=3,
+ params=_params)
+ _params['endpoints'] = endpoints
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(None)
+ async def DestroyUnits(self, unit_names):
+ '''
+ unit_names : typing.Sequence[str]
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='DestroyUnits',
+ version=3,
+ params=_params)
+ _params['unit-names'] = unit_names
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(None)
+ async def Expose(self, application):
+ '''
+ application : str
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='Expose',
+ version=3,
+ params=_params)
+ _params['application'] = application
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(ApplicationGetResults)
+ async def Get(self, application):
+ '''
+ application : str
+ Returns -> typing.Union[str, typing.Mapping[str, typing.Any], _ForwardRef('Value')]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='Get',
+ version=3,
+ params=_params)
+ _params['application'] = application
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(StringResult)
+ async def GetCharmURL(self, application):
+ '''
+ application : str
+ Returns -> typing.Union[_ForwardRef('Error'), str]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='GetCharmURL',
+ version=3,
+ params=_params)
+ _params['application'] = application
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(GetConstraintsResults)
+ async def GetConstraints(self, application):
+ '''
+ application : str
+ Returns -> Value
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='GetConstraints',
+ version=3,
+ params=_params)
+ _params['application'] = application
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(None)
+ async def Set(self, application, options):
+ '''
+ application : str
+ options : typing.Mapping[str, str]
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _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, config_settings, config_settings_yaml, force_series, force_units, resource_ids, storage_constraints):
+ '''
+ application : str
+ channel : str
+ charm_url : str
+ config_settings : typing.Mapping[str, str]
+ config_settings_yaml : str
+ force_series : bool
+ force_units : bool
+ resource_ids : typing.Mapping[str, str]
+ storage_constraints : typing.Mapping[str, ~StorageConstraints]
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _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
+
+
+
+ @ReturnMapping(None)
+ async def SetConstraints(self, application, constraints):
+ '''
+ application : str
+ constraints : Value
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _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
+
+
+
+ @ReturnMapping(ErrorResults)
+ async def SetMetricCredentials(self, creds):
+ '''
+ creds : typing.Sequence[~ApplicationMetricCredential]
+ Returns -> typing.Sequence[~ErrorResult]
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='SetMetricCredentials',
+ version=3,
+ params=_params)
+ _params['creds'] = creds
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(None)
+ async def Unexpose(self, application):
+ '''
+ application : str
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='Application',
+ request='Unexpose',
+ version=3,
+ params=_params)
+ _params['application'] = application
+ reply = await self.rpc(msg)
+ return reply
+
+
+
+ @ReturnMapping(None)
+ async def Unset(self, application, options):
+ '''
+ application : str
+ options : typing.Sequence[str]
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _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
+
+
+
+ @ReturnMapping(None)
+ async def Update(self, application, charm_url, constraints, force_charm_url, force_series, min_units, settings, settings_yaml):
+ '''
+ application : str
+ charm_url : str
+ constraints : Value
+ force_charm_url : bool
+ force_series : bool
+ min_units : int
+ settings : typing.Mapping[str, str]
+ settings_yaml : str
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _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 CloudFacade(Type):
+ name = 'Cloud'
+ version = 3
+ schema = {'definitions': {'AddCloudArgs': {'additionalProperties': False,
+ 'properties': {'cloud': {'$ref': '#/definitions/Cloud'},
+ 'name': {'type': 'string'}},
+ 'required': ['cloud', 'name'],
+ 'type': 'object'},
+ 'Cloud': {'additionalProperties': False,
+ 'properties': {'auth-types': {'items': {'type': 'string'},
+ 'type': 'array'},
+ 'ca-certificates': {'items': {'type': 'string'},
+ 'type': 'array'},
+ 'endpoint': {'type': 'string'},
+ 'identity-endpoint': {'type': 'string'},
+ 'regions': {'items': {'$ref': '#/definitions/CloudRegion'},
+ 'type': 'array'},
+ 'storage-endpoint': {'type': 'string'},
+ 'type': {'type': 'string'}},
+ 'required': ['type'],
+ 'type': 'object'},
+ 'CloudCredential': {'additionalProperties': False,
+ 'properties': {'attrs': {'patternProperties': {'.*': {'type': 'string'}},
+ 'type': 'object'},
+ 'auth-type': {'type': 'string'},
+ 'redacted': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'required': ['auth-type'],
+ 'type': 'object'},
+ 'CloudCredentialArg': {'additionalProperties': False,
+ 'properties': {'cloud-name': {'type': 'string'},
+ 'credential-name': {'type': 'string'}},
+ 'required': ['cloud-name',
+ 'credential-name'],
+ 'type': 'object'},
+ 'CloudCredentialArgs': {'additionalProperties': False,
+ 'properties': {'credentials': {'items': {'$ref': '#/definitions/CloudCredentialArg'},
+ 'type': 'array'},
+ 'include-secrets': {'type': 'boolean'}},
+ 'required': ['include-secrets'],
+ 'type': 'object'},
+ 'CloudCredentialResult': {'additionalProperties': False,
+ 'properties': {'error': {'$ref': '#/definitions/Error'},
+ 'result': {'$ref': '#/definitions/CloudCredential'}},
+ 'type': 'object'},
+ 'CloudCredentialResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/CloudCredentialResult'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'CloudDetails': {'additionalProperties': False,
+ 'properties': {'auth-types': {'items': {'type': 'string'},
+ 'type': 'array'},
+ 'endpoint': {'type': 'string'},
+ 'identity-endpoint': {'type': 'string'},
+ 'regions': {'items': {'$ref': '#/definitions/CloudRegion'},
+ 'type': 'array'},
+ 'storage-endpoint': {'type': 'string'},
+ 'type': {'type': 'string'}},
+ 'required': ['type'],
+ 'type': 'object'},
+ 'CloudInfo': {'additionalProperties': False,
+ 'properties': {'CloudDetails': {'$ref': '#/definitions/CloudDetails'},
+ 'users': {'items': {'$ref': '#/definitions/CloudUserInfo'},
+ 'type': 'array'}},
+ 'required': ['CloudDetails', 'users'],
+ 'type': 'object'},
+ 'CloudInfoResult': {'additionalProperties': False,
+ 'properties': {'error': {'$ref': '#/definitions/Error'},
+ 'result': {'$ref': '#/definitions/CloudInfo'}},
+ 'type': 'object'},
+ 'CloudInfoResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/CloudInfoResult'},
+ 'type': 'array'}},
+ 'required': ['results'],
+ 'type': 'object'},
+ 'CloudInstanceTypesConstraint': {'additionalProperties': False,
+ 'properties': {'cloud-tag': {'type': 'string'},
+ 'constraints': {'$ref': '#/definitions/Value'},
+ 'region': {'type': 'string'}},
+ 'required': ['cloud-tag',
+ 'region'],
+ 'type': 'object'},
+ 'CloudInstanceTypesConstraints': {'additionalProperties': False,
+ 'properties': {'constraints': {'items': {'$ref': '#/definitions/CloudInstanceTypesConstraint'},
+ 'type': 'array'}},
+ 'required': ['constraints'],
+ 'type': 'object'},
+ 'CloudRegion': {'additionalProperties': False,
+ 'properties': {'endpoint': {'type': 'string'},
+ 'identity-endpoint': {'type': 'string'},
+ 'name': {'type': 'string'},
+ 'storage-endpoint': {'type': 'string'}},
+ 'required': ['name'],
+ 'type': 'object'},
+ 'CloudResult': {'additionalProperties': False,
+ 'properties': {'cloud': {'$ref': '#/definitions/Cloud'},
+ 'error': {'$ref': '#/definitions/Error'}},
+ 'type': 'object'},
+ 'CloudResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/CloudResult'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'CloudUserInfo': {'additionalProperties': False,
+ 'properties': {'access': {'type': 'string'},
+ 'display-name': {'type': 'string'},
+ 'user': {'type': 'string'}},
+ 'required': ['user',
+ 'display-name',
+ 'access'],
+ 'type': 'object'},
+ 'CloudsResult': {'additionalProperties': False,
+ 'properties': {'clouds': {'patternProperties': {'.*': {'$ref': '#/definitions/Cloud'}},
+ 'type': 'object'}},
+ 'type': 'object'},
+ 'ControllerCredentialInfo': {'additionalProperties': False,
+ 'properties': {'content': {'$ref': '#/definitions/CredentialContent'},
+ 'models': {'items': {'$ref': '#/definitions/ModelAccess'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'CredentialContent': {'additionalProperties': False,
+ 'properties': {'attrs': {'patternProperties': {'.*': {'type': 'string'}},
+ 'type': 'object'},
+ 'auth-type': {'type': 'string'},
+ 'cloud': {'type': 'string'},
+ 'name': {'type': 'string'}},
+ 'required': ['name',
+ 'cloud',
+ 'auth-type'],
+ 'type': 'object'},
+ 'CredentialContentResult': {'additionalProperties': False,
+ 'properties': {'error': {'$ref': '#/definitions/Error'},
+ 'result': {'$ref': '#/definitions/ControllerCredentialInfo'}},
+ 'type': 'object'},
+ 'CredentialContentResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/CredentialContentResult'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'Entities': {'additionalProperties': False,
+ 'properties': {'entities': {'items': {'$ref': '#/definitions/Entity'},
+ 'type': 'array'}},
+ 'required': ['entities'],
+ 'type': 'object'},
+ 'Entity': {'additionalProperties': False,
+ 'properties': {'tag': {'type': 'string'}},
+ 'required': ['tag'],
+ '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'},
+ 'InstanceType': {'additionalProperties': False,
+ 'properties': {'arches': {'items': {'type': 'string'},
+ 'type': 'array'},
+ 'cost': {'type': 'integer'},
+ 'cpu-cores': {'type': 'integer'},
+ 'deprecated': {'type': 'boolean'},
+ 'memory': {'type': 'integer'},
+ 'name': {'type': 'string'},
+ 'root-disk': {'type': 'integer'},
+ 'virt-type': {'type': 'string'}},
+ 'required': ['arches', 'cpu-cores', 'memory'],
+ 'type': 'object'},
+ 'InstanceTypesResult': {'additionalProperties': False,
+ 'properties': {'cost-currency': {'type': 'string'},
+ 'cost-divisor': {'type': 'integer'},
+ 'cost-unit': {'type': 'string'},
+ 'error': {'$ref': '#/definitions/Error'},
+ 'instance-types': {'items': {'$ref': '#/definitions/InstanceType'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'InstanceTypesResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/InstanceTypesResult'},
+ 'type': 'array'}},
+ 'required': ['results'],
+ 'type': 'object'},
+ 'ListCloudInfo': {'additionalProperties': False,
+ 'properties': {'CloudDetails': {'$ref': '#/definitions/CloudDetails'},
+ 'user-access': {'type': 'string'}},
+ 'required': ['CloudDetails', 'user-access'],
+ 'type': 'object'},
+ 'ListCloudInfoResult': {'additionalProperties': False,
+ 'properties': {'error': {'$ref': '#/definitions/Error'},
+ 'result': {'$ref': '#/definitions/ListCloudInfo'}},
+ 'type': 'object'},
+ 'ListCloudInfoResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/ListCloudInfoResult'},
+ 'type': 'array'}},
+ 'required': ['results'],
+ 'type': 'object'},
+ 'ListCloudsRequest': {'additionalProperties': False,
+ 'properties': {'all': {'type': 'boolean'},
+ 'user-tag': {'type': 'string'}},
+ 'required': ['user-tag'],
+ 'type': 'object'},
+ 'Macaroon': {'additionalProperties': False, 'type': 'object'},
+ 'ModelAccess': {'additionalProperties': False,
+ 'properties': {'access': {'type': 'string'},
+ 'model': {'type': 'string'}},
+ 'type': 'object'},
+ 'ModifyCloudAccess': {'additionalProperties': False,
+ 'properties': {'access': {'type': 'string'},
+ 'action': {'type': 'string'},
+ 'cloud-tag': {'type': 'string'},
+ 'user-tag': {'type': 'string'}},
+ 'required': ['user-tag',
+ 'cloud-tag',
+ 'action',
+ 'access'],
+ 'type': 'object'},
+ 'ModifyCloudAccessRequest': {'additionalProperties': False,
+ 'properties': {'changes': {'items': {'$ref': '#/definitions/ModifyCloudAccess'},
+ 'type': 'array'}},
+ 'required': ['changes'],
+ 'type': 'object'},
+ 'RevokeCredentialArg': {'additionalProperties': False,
+ 'properties': {'force': {'type': 'boolean'},
+ 'tag': {'type': 'string'}},
+ 'required': ['tag', 'force'],
+ 'type': 'object'},
+ 'RevokeCredentialArgs': {'additionalProperties': False,
+ 'properties': {'credentials': {'items': {'$ref': '#/definitions/RevokeCredentialArg'},
+ 'type': 'array'}},
+ 'required': ['credentials'],
+ 'type': 'object'},
+ 'StringResult': {'additionalProperties': False,
+ 'properties': {'error': {'$ref': '#/definitions/Error'},
+ 'result': {'type': 'string'}},
+ 'required': ['result'],
+ 'type': 'object'},
+ 'StringsResult': {'additionalProperties': False,
+ 'properties': {'error': {'$ref': '#/definitions/Error'},
+ 'result': {'items': {'type': 'string'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'StringsResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/StringsResult'},
+ 'type': 'array'}},
+ 'required': ['results'],
+ 'type': 'object'},
+ 'TaggedCredential': {'additionalProperties': False,
+ 'properties': {'credential': {'$ref': '#/definitions/CloudCredential'},
+ 'tag': {'type': 'string'}},
+ 'required': ['tag', 'credential'],
+ 'type': 'object'},
+ 'TaggedCredentials': {'additionalProperties': False,
+ 'properties': {'credentials': {'items': {'$ref': '#/definitions/TaggedCredential'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'UpdateCredentialArgs': {'additionalProperties': False,
+ 'properties': {'credentials': {'items': {'$ref': '#/definitions/TaggedCredential'},
+ 'type': 'array'},
+ 'force': {'type': 'boolean'}},
+ 'required': ['credentials', 'force'],
+ 'type': 'object'},
+ 'UpdateCredentialModelResult': {'additionalProperties': False,
+ 'properties': {'errors': {'items': {'$ref': '#/definitions/ErrorResult'},
+ 'type': 'array'},
+ 'name': {'type': 'string'},
+ 'uuid': {'type': 'string'}},
+ 'required': ['uuid', 'name'],
+ 'type': 'object'},
+ 'UpdateCredentialResult': {'additionalProperties': False,
+ 'properties': {'error': {'$ref': '#/definitions/Error'},
+ 'models': {'items': {'$ref': '#/definitions/UpdateCredentialModelResult'},
+ 'type': 'array'},
+ 'tag': {'type': 'string'}},
+ 'required': ['tag'],
+ 'type': 'object'},
+ 'UpdateCredentialResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/UpdateCredentialResult'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'UserCloud': {'additionalProperties': False,
+ 'properties': {'cloud-tag': {'type': 'string'},
+ 'user-tag': {'type': 'string'}},
+ 'required': ['user-tag', 'cloud-tag'],
+ 'type': 'object'},
+ 'UserClouds': {'additionalProperties': False,
+ 'properties': {'user-clouds': {'items': {'$ref': '#/definitions/UserCloud'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'Value': {'additionalProperties': False,
+ 'properties': {'arch': {'type': 'string'},
+ 'container': {'type': 'string'},
+ 'cores': {'type': 'integer'},
+ 'cpu-power': {'type': 'integer'},
+ 'instance-type': {'type': 'string'},
+ 'mem': {'type': 'integer'},
+ 'root-disk': {'type': 'integer'},
+ 'spaces': {'items': {'type': 'string'},
+ 'type': 'array'},
+ 'tags': {'items': {'type': 'string'},
+ 'type': 'array'},
+ 'virt-type': {'type': 'string'},
+ 'zones': {'items': {'type': 'string'},
+ 'type': 'array'}},
'type': 'object'}},
- 'properties': {'AddRelation': {'properties': {'Params': {'$ref': '#/definitions/AddRelation'},
- 'Result': {'$ref': '#/definitions/AddRelationResults'}},
- 'type': 'object'},
- 'AddUnits': {'properties': {'Params': {'$ref': '#/definitions/AddApplicationUnits'},
- 'Result': {'$ref': '#/definitions/AddApplicationUnitsResults'}},
+ 'properties': {'AddCloud': {'properties': {'Params': {'$ref': '#/definitions/AddCloudArgs'}},
'type': 'object'},
- 'CharmRelations': {'properties': {'Params': {'$ref': '#/definitions/ApplicationCharmRelations'},
- 'Result': {'$ref': '#/definitions/ApplicationCharmRelationsResults'}},
+ 'AddCredentials': {'properties': {'Params': {'$ref': '#/definitions/TaggedCredentials'},
+ 'Result': {'$ref': '#/definitions/ErrorResults'}},
'type': 'object'},
- 'Deploy': {'properties': {'Params': {'$ref': '#/definitions/ApplicationsDeploy'},
- 'Result': {'$ref': '#/definitions/ErrorResults'}},
+ 'CheckCredentialsModels': {'properties': {'Params': {'$ref': '#/definitions/TaggedCredentials'},
+ 'Result': {'$ref': '#/definitions/UpdateCredentialResults'}},
+ 'type': 'object'},
+ 'Cloud': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/CloudResults'}},
+ 'type': 'object'},
+ 'CloudInfo': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/CloudInfoResults'}},
+ 'type': 'object'},
+ 'Clouds': {'properties': {'Result': {'$ref': '#/definitions/CloudsResult'}},
'type': 'object'},
- 'Destroy': {'properties': {'Params': {'$ref': '#/definitions/ApplicationDestroy'}},
- 'type': 'object'},
- 'DestroyRelation': {'properties': {'Params': {'$ref': '#/definitions/DestroyRelation'}},
- 'type': 'object'},
- 'DestroyUnits': {'properties': {'Params': {'$ref': '#/definitions/DestroyApplicationUnits'}},
+ 'Credential': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/CloudCredentialResults'}},
+ 'type': 'object'},
+ 'CredentialContents': {'properties': {'Params': {'$ref': '#/definitions/CloudCredentialArgs'},
+ 'Result': {'$ref': '#/definitions/CredentialContentResults'}},
+ 'type': 'object'},
+ 'DefaultCloud': {'properties': {'Result': {'$ref': '#/definitions/StringResult'}},
'type': 'object'},
- 'Expose': {'properties': {'Params': {'$ref': '#/definitions/ApplicationExpose'}},
- 'type': 'object'},
- 'Get': {'properties': {'Params': {'$ref': '#/definitions/ApplicationGet'},
- 'Result': {'$ref': '#/definitions/ApplicationGetResults'}},
- 'type': 'object'},
- 'GetCharmURL': {'properties': {'Params': {'$ref': '#/definitions/ApplicationGet'},
- 'Result': {'$ref': '#/definitions/StringResult'}},
- 'type': 'object'},
- 'GetConstraints': {'properties': {'Params': {'$ref': '#/definitions/GetApplicationConstraints'},
- 'Result': {'$ref': '#/definitions/GetConstraintsResults'}},
- 'type': 'object'},
- 'Set': {'properties': {'Params': {'$ref': '#/definitions/ApplicationSet'}},
- 'type': 'object'},
- 'SetCharm': {'properties': {'Params': {'$ref': '#/definitions/ApplicationSetCharm'}},
- 'type': 'object'},
- 'SetConstraints': {'properties': {'Params': {'$ref': '#/definitions/SetConstraints'}},
- 'type': 'object'},
- 'SetMetricCredentials': {'properties': {'Params': {'$ref': '#/definitions/ApplicationMetricCredentials'},
- 'Result': {'$ref': '#/definitions/ErrorResults'}},
- 'type': 'object'},
- 'Unexpose': {'properties': {'Params': {'$ref': '#/definitions/ApplicationUnexpose'}},
- 'type': 'object'},
- 'Unset': {'properties': {'Params': {'$ref': '#/definitions/ApplicationUnset'}},
- 'type': 'object'},
- 'Update': {'properties': {'Params': {'$ref': '#/definitions/ApplicationUpdate'}},
- 'type': 'object'}},
+ 'InstanceTypes': {'properties': {'Params': {'$ref': '#/definitions/CloudInstanceTypesConstraints'},
+ 'Result': {'$ref': '#/definitions/InstanceTypesResults'}},
+ 'type': 'object'},
+ 'ListCloudInfo': {'properties': {'Params': {'$ref': '#/definitions/ListCloudsRequest'},
+ 'Result': {'$ref': '#/definitions/ListCloudInfoResults'}},
+ 'type': 'object'},
+ 'ModifyCloudAccess': {'properties': {'Params': {'$ref': '#/definitions/ModifyCloudAccessRequest'},
+ 'Result': {'$ref': '#/definitions/ErrorResults'}},
+ 'type': 'object'},
+ 'RemoveClouds': {'properties': {'Params': {'$ref': '#/definitions/Entities'},
+ 'Result': {'$ref': '#/definitions/ErrorResults'}},
+ 'type': 'object'},
+ 'RevokeCredentialsCheckModels': {'properties': {'Params': {'$ref': '#/definitions/RevokeCredentialArgs'},
+ 'Result': {'$ref': '#/definitions/ErrorResults'}},
+ 'type': 'object'},
+ 'UpdateCredentialsCheckModels': {'properties': {'Params': {'$ref': '#/definitions/UpdateCredentialArgs'},
+ 'Result': {'$ref': '#/definitions/UpdateCredentialResults'}},
+ 'type': 'object'},
+ 'UserCredentials': {'properties': {'Params': {'$ref': '#/definitions/UserClouds'},
+ 'Result': {'$ref': '#/definitions/StringsResults'}},
+ 'type': 'object'}},
'type': 'object'}
- @ReturnMapping(AddRelationResults)
- async def AddRelation(self, endpoints):
+ @ReturnMapping(None)
+ async def AddCloud(self, cloud, name):
'''
- endpoints : typing.Sequence<+T_co>[str]
- Returns -> typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
+ cloud : Cloud
+ name : str
+ Returns -> None
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='AddRelation', version=3, params=_params)
- _params['endpoints'] = endpoints
+ msg = dict(type='Cloud',
+ request='AddCloud',
+ version=3,
+ params=_params)
+ _params['cloud'] = cloud
+ _params['name'] = name
reply = await self.rpc(msg)
return reply
- @ReturnMapping(AddApplicationUnitsResults)
- async def AddUnits(self, application, num_units, placement):
+ @ReturnMapping(ErrorResults)
+ async def AddCredentials(self, credentials):
'''
- application : str
- num_units : int
- placement : typing.Sequence<+T_co>[~Placement]<~Placement>
- Returns -> typing.Sequence<+T_co>[str]
+ credentials : typing.Sequence[~TaggedCredential]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='AddUnits', version=3, params=_params)
- _params['application'] = application
- _params['num-units'] = num_units
- _params['placement'] = placement
+ msg = dict(type='Cloud',
+ request='AddCredentials',
+ version=3,
+ params=_params)
+ _params['credentials'] = credentials
reply = await self.rpc(msg)
return reply
- @ReturnMapping(ApplicationCharmRelationsResults)
- async def CharmRelations(self, application):
+ @ReturnMapping(UpdateCredentialResults)
+ async def CheckCredentialsModels(self, credentials):
'''
- application : str
- Returns -> typing.Sequence<+T_co>[str]
+ credentials : typing.Sequence[~TaggedCredential]
+ Returns -> typing.Sequence[~UpdateCredentialResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='CharmRelations', version=3, params=_params)
- _params['application'] = application
+ msg = dict(type='Cloud',
+ request='CheckCredentialsModels',
+ version=3,
+ params=_params)
+ _params['credentials'] = credentials
reply = await self.rpc(msg)
return reply
- @ReturnMapping(ErrorResults)
- async def Deploy(self, applications):
+ @ReturnMapping(CloudResults)
+ async def Cloud(self, entities):
'''
- applications : typing.Sequence<+T_co>[~ApplicationDeploy]<~ApplicationDeploy>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~CloudResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='Deploy', version=3, params=_params)
- _params['applications'] = applications
+ msg = dict(type='Cloud',
+ request='Cloud',
+ version=3,
+ params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
- @ReturnMapping(None)
- async def Destroy(self, application):
+ @ReturnMapping(CloudInfoResults)
+ async def CloudInfo(self, entities):
'''
- application : str
- Returns -> None
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~CloudInfoResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='Destroy', version=3, params=_params)
- _params['application'] = application
+ msg = dict(type='Cloud',
+ request='CloudInfo',
+ version=3,
+ params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
- @ReturnMapping(None)
- async def DestroyRelation(self, endpoints):
- '''
- endpoints : typing.Sequence<+T_co>[str]
- Returns -> None
+ @ReturnMapping(CloudsResult)
+ async def Clouds(self):
'''
- # map input types to rpc msg
- _params = dict()
- msg = dict(type='Application', request='DestroyRelation', version=3, params=_params)
- _params['endpoints'] = endpoints
- reply = await self.rpc(msg)
- return reply
-
-
- @ReturnMapping(None)
- async def DestroyUnits(self, unit_names):
- '''
- unit_names : typing.Sequence<+T_co>[str]
- Returns -> None
+ Returns -> typing.Mapping[str, ~Cloud]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='DestroyUnits', version=3, params=_params)
- _params['unit-names'] = unit_names
+ msg = dict(type='Cloud',
+ request='Clouds',
+ version=3,
+ params=_params)
+
reply = await self.rpc(msg)
return reply
- @ReturnMapping(None)
- async def Expose(self, application):
+ @ReturnMapping(CloudCredentialResults)
+ async def Credential(self, entities):
'''
- application : str
- Returns -> None
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~CloudCredentialResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='Expose', version=3, params=_params)
- _params['application'] = application
+ msg = dict(type='Cloud',
+ request='Credential',
+ version=3,
+ params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
- @ReturnMapping(ApplicationGetResults)
- async def Get(self, application):
+ @ReturnMapping(CredentialContentResults)
+ async def CredentialContents(self, credentials, include_secrets):
'''
- application : str
- Returns -> typing.Union[str, typing.Mapping<~KT, +VT_co>[str, typing.Any], _ForwardRef('Value')]
+ credentials : typing.Sequence[~CloudCredentialArg]
+ include_secrets : bool
+ Returns -> typing.Sequence[~CredentialContentResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='Get', version=3, params=_params)
- _params['application'] = application
+ msg = dict(type='Cloud',
+ request='CredentialContents',
+ version=3,
+ params=_params)
+ _params['credentials'] = credentials
+ _params['include-secrets'] = include_secrets
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringResult)
- async def GetCharmURL(self, application):
+ async def DefaultCloud(self):
'''
- application : str
+
Returns -> typing.Union[_ForwardRef('Error'), str]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='GetCharmURL', version=3, params=_params)
- _params['application'] = application
- reply = await self.rpc(msg)
- return reply
+ msg = dict(type='Cloud',
+ request='DefaultCloud',
+ version=3,
+ params=_params)
-
-
- @ReturnMapping(GetConstraintsResults)
- async def GetConstraints(self, application):
- '''
- application : str
- Returns -> Value
- '''
- # map input types to rpc msg
- _params = dict()
- msg = dict(type='Application', request='GetConstraints', version=3, params=_params)
- _params['application'] = application
reply = await self.rpc(msg)
return reply
- @ReturnMapping(None)
- async def Set(self, application, options):
+ @ReturnMapping(InstanceTypesResults)
+ async def InstanceTypes(self, constraints):
'''
- application : str
- options : typing.Mapping<~KT, +VT_co>[str, str]
- Returns -> None
+ constraints : typing.Sequence[~CloudInstanceTypesConstraint]
+ Returns -> typing.Sequence[~InstanceTypesResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='Set', version=3, params=_params)
- _params['application'] = application
- _params['options'] = options
+ msg = dict(type='Cloud',
+ request='InstanceTypes',
+ version=3,
+ params=_params)
+ _params['constraints'] = constraints
reply = await self.rpc(msg)
return reply
- @ReturnMapping(None)
- async def SetCharm(self, application, channel, charm_url, config_settings, config_settings_yaml, force_series, force_units, resource_ids, storage_constraints):
+ @ReturnMapping(ListCloudInfoResults)
+ async def ListCloudInfo(self, all_, user_tag):
'''
- 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
+ all_ : bool
+ user_tag : str
+ Returns -> typing.Sequence[~ListCloudInfoResult]
'''
# map input types to rpc msg
_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
+ msg = dict(type='Cloud',
+ request='ListCloudInfo',
+ version=3,
+ params=_params)
+ _params['all'] = all_
+ _params['user-tag'] = user_tag
reply = await self.rpc(msg)
return reply
- @ReturnMapping(None)
- async def SetConstraints(self, application, constraints):
+ @ReturnMapping(ErrorResults)
+ async def ModifyCloudAccess(self, changes):
'''
- application : str
- constraints : Value
- Returns -> None
+ changes : typing.Sequence[~ModifyCloudAccess]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='SetConstraints', version=3, params=_params)
- _params['application'] = application
- _params['constraints'] = constraints
+ msg = dict(type='Cloud',
+ request='ModifyCloudAccess',
+ version=3,
+ params=_params)
+ _params['changes'] = changes
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
- async def SetMetricCredentials(self, creds):
+ async def RemoveClouds(self, entities):
'''
- creds : typing.Sequence<+T_co>[~ApplicationMetricCredential]<~ApplicationMetricCredential>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='SetMetricCredentials', version=3, params=_params)
- _params['creds'] = creds
+ msg = dict(type='Cloud',
+ request='RemoveClouds',
+ version=3,
+ params=_params)
+ _params['entities'] = entities
reply = await self.rpc(msg)
return reply
- @ReturnMapping(None)
- async def Unexpose(self, application):
+ @ReturnMapping(ErrorResults)
+ async def RevokeCredentialsCheckModels(self, credentials):
'''
- application : str
- Returns -> None
+ credentials : typing.Sequence[~RevokeCredentialArg]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='Unexpose', version=3, params=_params)
- _params['application'] = application
+ msg = dict(type='Cloud',
+ request='RevokeCredentialsCheckModels',
+ version=3,
+ params=_params)
+ _params['credentials'] = credentials
reply = await self.rpc(msg)
return reply
- @ReturnMapping(None)
- async def Unset(self, application, options):
+ @ReturnMapping(UpdateCredentialResults)
+ async def UpdateCredentialsCheckModels(self, credentials, force):
'''
- application : str
- options : typing.Sequence<+T_co>[str]
- Returns -> None
+ credentials : typing.Sequence[~TaggedCredential]
+ force : bool
+ Returns -> typing.Sequence[~UpdateCredentialResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Application', request='Unset', version=3, params=_params)
- _params['application'] = application
- _params['options'] = options
+ msg = dict(type='Cloud',
+ request='UpdateCredentialsCheckModels',
+ version=3,
+ params=_params)
+ _params['credentials'] = credentials
+ _params['force'] = force
reply = await self.rpc(msg)
return reply
- @ReturnMapping(None)
- async def Update(self, application, charm_url, constraints, force_charm_url, force_series, min_units, settings, settings_yaml):
+ @ReturnMapping(StringsResults)
+ async def UserCredentials(self, user_clouds):
'''
- application : str
- charm_url : str
- constraints : Value
- force_charm_url : bool
- force_series : bool
- min_units : int
- settings : typing.Mapping<~KT, +VT_co>[str, str]
- settings_yaml : str
- Returns -> None
+ user_clouds : typing.Sequence[~UserCloud]
+ Returns -> typing.Sequence[~StringsResult]
'''
# map input types to rpc msg
_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
+ msg = dict(type='Cloud',
+ request='UserCredentials',
+ version=3,
+ params=_params)
+ _params['user-clouds'] = user_clouds
reply = await self.rpc(msg)
return reply
async def AllModels(self):
'''
- Returns -> typing.Sequence<+T_co>[~UserModel]<~UserModel>
+ Returns -> typing.Sequence[~UserModel]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='AllModels', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='AllModels',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(CloudSpecResults)
async def CloudSpec(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~CloudSpecResult]<~CloudSpecResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~CloudSpecResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='CloudSpec', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='CloudSpec',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
async def ControllerConfig(self):
'''
- Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ Returns -> typing.Mapping[str, typing.Any]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='ControllerConfig', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='ControllerConfig',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='DestroyController', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='DestroyController',
+ version=3,
+ params=_params)
_params['destroy-models'] = destroy_models
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='GetCloudSpec', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='GetCloudSpec',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(UserAccessResults)
async def GetControllerAccess(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~UserAccessResult]<~UserAccessResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~UserAccessResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='GetControllerAccess', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='GetControllerAccess',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
async def HostedModelConfigs(self):
'''
- Returns -> typing.Sequence<+T_co>[~HostedModelConfig]<~HostedModelConfig>
+ Returns -> typing.Sequence[~HostedModelConfig]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='HostedModelConfigs', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='HostedModelConfigs',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(InitiateMigrationResults)
async def InitiateMigration(self, specs):
'''
- specs : typing.Sequence<+T_co>[~MigrationSpec]<~MigrationSpec>
- Returns -> typing.Sequence<+T_co>[~InitiateMigrationResult]<~InitiateMigrationResult>
+ specs : typing.Sequence[~MigrationSpec]
+ Returns -> typing.Sequence[~InitiateMigrationResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='InitiateMigration', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='InitiateMigration',
+ version=3,
+ params=_params)
_params['specs'] = specs
reply = await self.rpc(msg)
return reply
async def ListBlockedModels(self):
'''
- Returns -> typing.Sequence<+T_co>[~ModelBlockInfo]<~ModelBlockInfo>
+ Returns -> typing.Sequence[~ModelBlockInfo]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='ListBlockedModels', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='ListBlockedModels',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
async def ModelConfig(self):
'''
- Returns -> typing.Mapping<~KT, +VT_co>[str, ~ConfigValue]<~ConfigValue>
+ Returns -> typing.Mapping[str, ~ConfigValue]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='ModelConfig', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='ModelConfig',
+ version=3,
+ params=_params)
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>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ModelStatus]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='ModelStatus', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='ModelStatus',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def ModifyControllerAccess(self, changes):
'''
- changes : typing.Sequence<+T_co>[~ModifyControllerAccess]<~ModifyControllerAccess>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ changes : typing.Sequence[~ModifyControllerAccess]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='ModifyControllerAccess', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='ModifyControllerAccess',
+ version=3,
+ params=_params)
_params['changes'] = changes
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='RemoveBlocks', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='RemoveBlocks',
+ version=3,
+ params=_params)
_params['all'] = all_
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Controller', request='WatchAllModels', version=3, params=_params)
+ msg = dict(type='Controller',
+ request='WatchAllModels',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(CloudSpecResults)
async def CloudSpec(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~CloudSpecResult]<~CloudSpecResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~CloudSpecResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='CloudSpec', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='CloudSpec',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringResults)
async def GetAssignedMachine(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StringResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='GetAssignedMachine', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='GetAssignedMachine',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='GetCloudSpec', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='GetCloudSpec',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(BoolResults)
async def GetExposed(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~BoolResult]<~BoolResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~BoolResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='GetExposed', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='GetExposed',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringsResults)
async def GetMachineActiveSubnets(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StringsResult]<~StringsResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StringsResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='GetMachineActiveSubnets', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='GetMachineActiveSubnets',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(MachinePortsResults)
async def GetMachinePorts(self, params):
'''
- params : typing.Sequence<+T_co>[~MachinePorts]<~MachinePorts>
- Returns -> typing.Sequence<+T_co>[~MachinePortsResult]<~MachinePortsResult>
+ params : typing.Sequence[~MachinePorts]
+ Returns -> typing.Sequence[~MachinePortsResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='GetMachinePorts', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='GetMachinePorts',
+ version=3,
+ params=_params)
_params['params'] = params
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringResults)
async def InstanceId(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StringResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='InstanceId', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='InstanceId',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(LifeResults)
async def Life(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~LifeResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='Life', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='Life',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
async def ModelConfig(self):
'''
- Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ Returns -> typing.Mapping[str, typing.Any]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='ModelConfig', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='ModelConfig',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(NotifyWatchResults)
async def Watch(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~NotifyWatchResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='Watch', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='Watch',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='WatchForModelConfigChanges', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='WatchForModelConfigChanges',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
async def WatchModelMachines(self):
'''
- Returns -> typing.Union[typing.Sequence<+T_co>[str], _ForwardRef('Error')]
+ Returns -> typing.Union[typing.Sequence[str], _ForwardRef('Error'), str]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='WatchModelMachines', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='WatchModelMachines',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringsWatchResults)
async def WatchOpenedPorts(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StringsWatchResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='WatchOpenedPorts', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='WatchOpenedPorts',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringsWatchResults)
async def WatchUnits(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StringsWatchResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Firewaller', request='WatchUnits', version=3, params=_params)
+ msg = dict(type='Firewaller',
+ request='WatchUnits',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
+class ImageMetadataFacade(Type):
+ name = 'ImageMetadata'
+ version = 3
+ schema = {'properties': {'UpdateFromPublishedImages': {'type': 'object'}},
+ 'type': 'object'}
+
+
+ @ReturnMapping(None)
+ async def UpdateFromPublishedImages(self):
+ '''
+
+ Returns -> None
+ '''
+ # map input types to rpc msg
+ _params = dict()
+ msg = dict(type='ImageMetadata',
+ request='UpdateFromPublishedImages',
+ version=3,
+ params=_params)
+
+ reply = await self.rpc(msg)
+ return reply
+
+
+
class InstancePollerFacade(Type):
name = 'InstancePoller'
version = 3
@ReturnMapping(BoolResults)
async def AreManuallyProvisioned(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~BoolResult]<~BoolResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~BoolResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='InstancePoller', request='AreManuallyProvisioned', version=3, params=_params)
+ msg = dict(type='InstancePoller',
+ request='AreManuallyProvisioned',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringResults)
async def InstanceId(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StringResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='InstancePoller', request='InstanceId', version=3, params=_params)
+ msg = dict(type='InstancePoller',
+ request='InstanceId',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StatusResults)
async def InstanceStatus(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StatusResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='InstancePoller', request='InstanceStatus', version=3, params=_params)
+ msg = dict(type='InstancePoller',
+ request='InstanceStatus',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(LifeResults)
async def Life(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~LifeResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='InstancePoller', request='Life', version=3, params=_params)
+ msg = dict(type='InstancePoller',
+ request='Life',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
async def ModelConfig(self):
'''
- Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ Returns -> typing.Mapping[str, typing.Any]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='InstancePoller', request='ModelConfig', version=3, params=_params)
+ msg = dict(type='InstancePoller',
+ request='ModelConfig',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(MachineAddressesResults)
async def ProviderAddresses(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~MachineAddressesResult]<~MachineAddressesResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~MachineAddressesResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='InstancePoller', request='ProviderAddresses', version=3, params=_params)
+ msg = dict(type='InstancePoller',
+ request='ProviderAddresses',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def SetInstanceStatus(self, entities):
'''
- entities : typing.Sequence<+T_co>[~EntityStatusArgs]<~EntityStatusArgs>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~EntityStatusArgs]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='InstancePoller', request='SetInstanceStatus', version=3, params=_params)
+ msg = dict(type='InstancePoller',
+ request='SetInstanceStatus',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def SetProviderAddresses(self, machine_addresses):
'''
- machine_addresses : typing.Sequence<+T_co>[~MachineAddresses]<~MachineAddresses>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ machine_addresses : typing.Sequence[~MachineAddresses]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='InstancePoller', request='SetProviderAddresses', version=3, params=_params)
+ msg = dict(type='InstancePoller',
+ request='SetProviderAddresses',
+ version=3,
+ params=_params)
_params['machine-addresses'] = machine_addresses
reply = await self.rpc(msg)
return reply
@ReturnMapping(StatusResults)
async def Status(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StatusResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='InstancePoller', request='Status', version=3, params=_params)
+ msg = dict(type='InstancePoller',
+ request='Status',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='InstancePoller', request='WatchForModelConfigChanges', version=3, params=_params)
+ msg = dict(type='InstancePoller',
+ request='WatchForModelConfigChanges',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
async def WatchModelMachines(self):
'''
- Returns -> typing.Union[typing.Sequence<+T_co>[str], _ForwardRef('Error')]
+ Returns -> typing.Union[typing.Sequence[str], _ForwardRef('Error'), str]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='InstancePoller', request='WatchModelMachines', version=3, params=_params)
+ msg = dict(type='InstancePoller',
+ request='WatchModelMachines',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(AddMachinesResults)
async def AddMachines(self, params):
'''
- params : typing.Sequence<+T_co>[~AddMachineParams]<~AddMachineParams>
- Returns -> typing.Sequence<+T_co>[~AddMachinesResult]<~AddMachinesResult>
+ params : typing.Sequence[~AddMachineParams]
+ Returns -> typing.Sequence[~AddMachinesResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='MachineManager', request='AddMachines', version=3, params=_params)
+ msg = dict(type='MachineManager',
+ request='AddMachines',
+ version=3,
+ params=_params)
_params['params'] = params
reply = await self.rpc(msg)
return reply
@ReturnMapping(DestroyMachineResults)
async def DestroyMachine(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~DestroyMachineResult]<~DestroyMachineResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~DestroyMachineResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='MachineManager', request='DestroyMachine', version=3, params=_params)
+ msg = dict(type='MachineManager',
+ request='DestroyMachine',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(DestroyMachineResults)
async def ForceDestroyMachine(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~DestroyMachineResult]<~DestroyMachineResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~DestroyMachineResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='MachineManager', request='ForceDestroyMachine', version=3, params=_params)
+ msg = dict(type='MachineManager',
+ request='ForceDestroyMachine',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(InstanceTypesResults)
async def InstanceTypes(self, constraints):
'''
- constraints : typing.Sequence<+T_co>[~ModelInstanceTypesConstraint]<~ModelInstanceTypesConstraint>
- Returns -> typing.Sequence<+T_co>[~InstanceTypesResult]<~InstanceTypesResult>
+ constraints : typing.Sequence[~ModelInstanceTypesConstraint]
+ Returns -> typing.Sequence[~InstanceTypesResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='MachineManager', request='InstanceTypes', version=3, params=_params)
+ msg = dict(type='MachineManager',
+ request='InstanceTypes',
+ version=3,
+ params=_params)
_params['constraints'] = constraints
reply = await self.rpc(msg)
return reply
async def CreateModel(self, cloud_tag, config, credential, name, owner_tag, region):
'''
cloud_tag : str
- config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ config : typing.Mapping[str, typing.Any]
credential : str
name : str
owner_tag : str
region : str
- Returns -> typing.Union[_ForwardRef('Number'), _ForwardRef('ModelMigrationStatus'), _ForwardRef('ModelSLAInfo'), _ForwardRef('EntityStatus'), typing.Sequence<+T_co>[~ModelUserInfo]<~ModelUserInfo>]
+ Returns -> typing.Union[_ForwardRef('Number'), str, typing.Sequence[~ModelMachineInfo], _ForwardRef('ModelMigrationStatus'), _ForwardRef('ModelSLAInfo'), _ForwardRef('EntityStatus'), typing.Sequence[~ModelUserInfo]]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='ModelManager', request='CreateModel', version=3, params=_params)
+ msg = dict(type='ModelManager',
+ request='CreateModel',
+ version=3,
+ params=_params)
_params['cloud-tag'] = cloud_tag
_params['config'] = config
_params['credential'] = credential
@ReturnMapping(ErrorResults)
async def DestroyModels(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='ModelManager', request='DestroyModels', version=3, params=_params)
+ msg = dict(type='ModelManager',
+ request='DestroyModels',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringResults)
async def DumpModels(self, entities, simplified):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+ entities : typing.Sequence[~Entity]
simplified : bool
- Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
+ Returns -> typing.Sequence[~StringResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='ModelManager', request='DumpModels', version=3, params=_params)
+ msg = dict(type='ModelManager',
+ request='DumpModels',
+ version=3,
+ params=_params)
_params['entities'] = entities
_params['simplified'] = simplified
reply = await self.rpc(msg)
@ReturnMapping(MapResults)
async def DumpModelsDB(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~MapResult]<~MapResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~MapResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='ModelManager', request='DumpModelsDB', version=3, params=_params)
+ msg = dict(type='ModelManager',
+ request='DumpModelsDB',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
async def ListModels(self, tag):
'''
tag : str
- Returns -> typing.Sequence<+T_co>[~UserModel]<~UserModel>
+ Returns -> typing.Sequence[~UserModel]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='ModelManager', request='ListModels', version=3, params=_params)
+ msg = dict(type='ModelManager',
+ request='ListModels',
+ version=3,
+ params=_params)
_params['tag'] = tag
reply = await self.rpc(msg)
return reply
async def ModelDefaults(self):
'''
- Returns -> typing.Mapping<~KT, +VT_co>[str, ~ModelDefaults]<~ModelDefaults>
+ Returns -> typing.Mapping[str, ~ModelDefaults]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='ModelManager', request='ModelDefaults', version=3, params=_params)
+ msg = dict(type='ModelManager',
+ request='ModelDefaults',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(ModelInfoResults)
async def ModelInfo(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ModelInfoResult]<~ModelInfoResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ModelInfoResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='ModelManager', request='ModelInfo', version=3, params=_params)
+ msg = dict(type='ModelManager',
+ request='ModelInfo',
+ version=3,
+ 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>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ModelStatus]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='ModelManager', request='ModelStatus', version=3, params=_params)
+ msg = dict(type='ModelManager',
+ request='ModelStatus',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def ModifyModelAccess(self, changes):
'''
- changes : typing.Sequence<+T_co>[~ModifyModelAccess]<~ModifyModelAccess>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ changes : typing.Sequence[~ModifyModelAccess]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='ModelManager', request='ModifyModelAccess', version=3, params=_params)
+ msg = dict(type='ModelManager',
+ request='ModifyModelAccess',
+ version=3,
+ 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>
+ config : typing.Sequence[~ModelDefaultValues]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='ModelManager', request='SetModelDefaults', version=3, params=_params)
+ msg = dict(type='ModelManager',
+ request='SetModelDefaults',
+ version=3,
+ 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>
+ keys : typing.Sequence[~ModelUnsetKeys]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='ModelManager', request='UnsetModelDefaults', version=3, params=_params)
+ msg = dict(type='ModelManager',
+ request='UnsetModelDefaults',
+ version=3,
+ params=_params)
_params['keys'] = keys
reply = await self.rpc(msg)
return reply
async def APIAddresses(self):
'''
- Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence<+T_co>[str]]
+ Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence[str]]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='APIAddresses', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='APIAddresses',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
async def APIHostPorts(self):
'''
- Returns -> typing.Sequence<+T_co>[~HostPort]<~HostPort>
+ Returns -> typing.Sequence[~HostPort]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='APIHostPorts', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='APIHostPorts',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
async def CACert(self):
'''
- Returns -> typing.Sequence<+T_co>[int]
+ Returns -> typing.Sequence[int]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='CACert', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='CACert',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(ConstraintsResults)
async def Constraints(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ConstraintsResult]<~ConstraintsResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ConstraintsResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='Constraints', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='Constraints',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
async def ContainerConfig(self):
'''
- Returns -> typing.Union[_ForwardRef('UpdateBehavior'), str, _ForwardRef('Settings'), _ForwardRef('Settings'), bool]
+ Returns -> typing.Union[_ForwardRef('UpdateBehavior'), str, _ForwardRef('Settings'), bool]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='ContainerConfig', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='ContainerConfig',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
async def ContainerManagerConfig(self, type_):
'''
type_ : str
- Returns -> typing.Mapping<~KT, +VT_co>[str, str]
+ Returns -> typing.Mapping[str, str]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='ContainerManagerConfig', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='ContainerManagerConfig',
+ version=3,
+ params=_params)
_params['type'] = type_
reply = await self.rpc(msg)
return reply
async def ControllerConfig(self):
'''
- Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ Returns -> typing.Mapping[str, typing.Any]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='ControllerConfig', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='ControllerConfig',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(DistributionGroupResults)
async def DistributionGroup(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~DistributionGroupResult]<~DistributionGroupResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~DistributionGroupResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='DistributionGroup', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='DistributionGroup',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def EnsureDead(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='EnsureDead', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='EnsureDead',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
minor : int
number : Number
series : str
- Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence<+T_co>[~Tools]<~Tools>]
+ Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence[~Tools]]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='FindTools', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='FindTools',
+ version=3,
+ params=_params)
_params['arch'] = arch
_params['major'] = major
_params['minor'] = minor
@ReturnMapping(MachineNetworkConfigResults)
async def GetContainerInterfaceInfo(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~MachineNetworkConfigResult]<~MachineNetworkConfigResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~MachineNetworkConfigResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='GetContainerInterfaceInfo', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='GetContainerInterfaceInfo',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(HostNetworkChangeResults)
async def HostChangesForContainers(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~HostNetworkChange]<~HostNetworkChange>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~HostNetworkChange]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='HostChangesForContainers', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='HostChangesForContainers',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringResults)
async def InstanceId(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StringResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='InstanceId', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='InstanceId',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StatusResults)
async def InstanceStatus(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StatusResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='InstanceStatus', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='InstanceStatus',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(LifeResults)
async def Life(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~LifeResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='Life', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='Life',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
async def MachinesWithTransientErrors(self):
'''
- Returns -> typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
+ Returns -> typing.Sequence[~StatusResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='MachinesWithTransientErrors', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='MachinesWithTransientErrors',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def MarkMachinesForRemoval(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='MarkMachinesForRemoval', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='MarkMachinesForRemoval',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
async def ModelConfig(self):
'''
- Returns -> typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ Returns -> typing.Mapping[str, typing.Any]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='ModelConfig', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='ModelConfig',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='ModelUUID', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='ModelUUID',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(MachineNetworkConfigResults)
async def PrepareContainerInterfaceInfo(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~MachineNetworkConfigResult]<~MachineNetworkConfigResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~MachineNetworkConfigResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='PrepareContainerInterfaceInfo', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='PrepareContainerInterfaceInfo',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ProvisioningInfoResults)
async def ProvisioningInfo(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ProvisioningInfoResult]<~ProvisioningInfoResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ProvisioningInfoResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='ProvisioningInfo', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='ProvisioningInfo',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def ReleaseContainerAddresses(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='ReleaseContainerAddresses', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='ReleaseContainerAddresses',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def Remove(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='Remove', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='Remove',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringResults)
async def Series(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StringResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='Series', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='Series',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(None)
async def SetHostMachineNetworkConfig(self, config, tag):
'''
- config : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
+ config : typing.Sequence[~NetworkConfig]
tag : str
Returns -> None
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='SetHostMachineNetworkConfig', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='SetHostMachineNetworkConfig',
+ version=3,
+ params=_params)
_params['config'] = config
_params['tag'] = tag
reply = await self.rpc(msg)
@ReturnMapping(ErrorResults)
async def SetInstanceInfo(self, machines):
'''
- machines : typing.Sequence<+T_co>[~InstanceInfo]<~InstanceInfo>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ machines : typing.Sequence[~InstanceInfo]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='SetInstanceInfo', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='SetInstanceInfo',
+ version=3,
+ params=_params)
_params['machines'] = machines
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def SetInstanceStatus(self, entities):
'''
- entities : typing.Sequence<+T_co>[~EntityStatusArgs]<~EntityStatusArgs>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~EntityStatusArgs]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='SetInstanceStatus', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='SetInstanceStatus',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(None)
async def SetObservedNetworkConfig(self, config, tag):
'''
- config : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
+ config : typing.Sequence[~NetworkConfig]
tag : str
Returns -> None
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='SetObservedNetworkConfig', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='SetObservedNetworkConfig',
+ version=3,
+ params=_params)
_params['config'] = config
_params['tag'] = tag
reply = await self.rpc(msg)
@ReturnMapping(ErrorResults)
async def SetPasswords(self, changes):
'''
- changes : typing.Sequence<+T_co>[~EntityPassword]<~EntityPassword>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ changes : typing.Sequence[~EntityPassword]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='SetPasswords', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='SetPasswords',
+ version=3,
+ params=_params)
_params['changes'] = changes
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def SetProviderNetworkConfig(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='SetProviderNetworkConfig', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='SetProviderNetworkConfig',
+ version=3,
+ params=_params)
_params['entities'] = entities
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>
+ entities : typing.Sequence[~EntityStatusArgs]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='SetStatus', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='SetStatus',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def SetSupportedContainers(self, params):
'''
- params : typing.Sequence<+T_co>[~MachineContainers]<~MachineContainers>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ params : typing.Sequence[~MachineContainers]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='SetSupportedContainers', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='SetSupportedContainers',
+ version=3,
+ params=_params)
_params['params'] = params
reply = await self.rpc(msg)
return reply
async def StateAddresses(self):
'''
- Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence<+T_co>[str]]
+ Returns -> typing.Union[_ForwardRef('Error'), typing.Sequence[str]]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='StateAddresses', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='StateAddresses',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(StatusResults)
async def Status(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StatusResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='Status', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='Status',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ToolsResults)
async def Tools(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ToolsResult]<~ToolsResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ToolsResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='Tools', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='Tools',
+ version=3,
+ params=_params)
_params['entities'] = entities
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>
+ entities : typing.Sequence[~EntityStatusArgs]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='UpdateStatus', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='UpdateStatus',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='WatchAPIHostPorts', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='WatchAPIHostPorts',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringsWatchResults)
async def WatchAllContainers(self, params):
'''
- params : typing.Sequence<+T_co>[~WatchContainer]<~WatchContainer>
- Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
+ params : typing.Sequence[~WatchContainer]
+ Returns -> typing.Sequence[~StringsWatchResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='WatchAllContainers', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='WatchAllContainers',
+ version=3,
+ params=_params)
_params['params'] = params
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringsWatchResults)
async def WatchContainers(self, params):
'''
- params : typing.Sequence<+T_co>[~WatchContainer]<~WatchContainer>
- Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
+ params : typing.Sequence[~WatchContainer]
+ Returns -> typing.Sequence[~StringsWatchResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='WatchContainers', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='WatchContainers',
+ version=3,
+ params=_params)
_params['params'] = params
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='WatchForModelConfigChanges', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='WatchForModelConfigChanges',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='WatchMachineErrorRetry', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='WatchMachineErrorRetry',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
async def WatchModelMachines(self):
'''
- Returns -> typing.Union[typing.Sequence<+T_co>[str], _ForwardRef('Error')]
+ Returns -> typing.Union[typing.Sequence[str], _ForwardRef('Error'), str]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Provisioner', request='WatchModelMachines', version=3, params=_params)
+ msg = dict(type='Provisioner',
+ request='WatchModelMachines',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def CreateSpaces(self, spaces):
'''
- spaces : typing.Sequence<+T_co>[~CreateSpaceParams]<~CreateSpaceParams>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ spaces : typing.Sequence[~CreateSpaceParams]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Spaces', request='CreateSpaces', version=3, params=_params)
+ msg = dict(type='Spaces',
+ request='CreateSpaces',
+ version=3,
+ params=_params)
_params['spaces'] = spaces
reply = await self.rpc(msg)
return reply
async def ListSpaces(self):
'''
- Returns -> typing.Sequence<+T_co>[~Space]<~Space>
+ Returns -> typing.Sequence[~Space]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Spaces', request='ListSpaces', version=3, params=_params)
+ msg = dict(type='Spaces',
+ request='ListSpaces',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Spaces', request='ReloadSpaces', version=3, params=_params)
+ msg = dict(type='Spaces',
+ request='ReloadSpaces',
+ version=3,
+ params=_params)
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def AddToUnit(self, storages):
'''
- storages : typing.Sequence<+T_co>[~StorageAddParams]<~StorageAddParams>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ storages : typing.Sequence[~StorageAddParams]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Storage', request='AddToUnit', version=3, params=_params)
+ msg = dict(type='Storage',
+ request='AddToUnit',
+ version=3,
+ params=_params)
_params['storages'] = storages
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def Attach(self, ids):
'''
- ids : typing.Sequence<+T_co>[~StorageAttachmentId]<~StorageAttachmentId>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ ids : typing.Sequence[~StorageAttachmentId]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Storage', request='Attach', version=3, params=_params)
+ msg = dict(type='Storage',
+ request='Attach',
+ version=3,
+ params=_params)
_params['ids'] = ids
reply = await self.rpc(msg)
return reply
@ReturnMapping(None)
async def CreatePool(self, attrs, name, provider):
'''
- attrs : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ attrs : typing.Mapping[str, typing.Any]
name : str
provider : str
Returns -> None
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Storage', request='CreatePool', version=3, params=_params)
+ msg = dict(type='Storage',
+ request='CreatePool',
+ version=3,
+ params=_params)
_params['attrs'] = attrs
_params['name'] = name
_params['provider'] = provider
@ReturnMapping(ErrorResults)
async def Destroy(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Storage', request='Destroy', version=3, params=_params)
+ msg = dict(type='Storage',
+ request='Destroy',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def Detach(self, ids):
'''
- ids : typing.Sequence<+T_co>[~StorageAttachmentId]<~StorageAttachmentId>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ ids : typing.Sequence[~StorageAttachmentId]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Storage', request='Detach', version=3, params=_params)
+ msg = dict(type='Storage',
+ request='Detach',
+ version=3,
+ params=_params)
_params['ids'] = ids
reply = await self.rpc(msg)
return reply
@ReturnMapping(FilesystemDetailsListResults)
async def ListFilesystems(self, filters):
'''
- filters : typing.Sequence<+T_co>[~FilesystemFilter]<~FilesystemFilter>
- Returns -> typing.Sequence<+T_co>[~FilesystemDetailsListResult]<~FilesystemDetailsListResult>
+ filters : typing.Sequence[~FilesystemFilter]
+ Returns -> typing.Sequence[~FilesystemDetailsListResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Storage', request='ListFilesystems', version=3, params=_params)
+ msg = dict(type='Storage',
+ request='ListFilesystems',
+ version=3,
+ params=_params)
_params['filters'] = filters
reply = await self.rpc(msg)
return reply
@ReturnMapping(StoragePoolsResults)
async def ListPools(self, filters):
'''
- filters : typing.Sequence<+T_co>[~StoragePoolFilter]<~StoragePoolFilter>
- Returns -> typing.Sequence<+T_co>[~StoragePoolsResult]<~StoragePoolsResult>
+ filters : typing.Sequence[~StoragePoolFilter]
+ Returns -> typing.Sequence[~StoragePoolsResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Storage', request='ListPools', version=3, params=_params)
+ msg = dict(type='Storage',
+ request='ListPools',
+ version=3,
+ params=_params)
_params['filters'] = filters
reply = await self.rpc(msg)
return reply
@ReturnMapping(StorageDetailsListResults)
async def ListStorageDetails(self, filters):
'''
- filters : typing.Sequence<+T_co>[~StorageFilter]<~StorageFilter>
- Returns -> typing.Sequence<+T_co>[~StorageDetailsListResult]<~StorageDetailsListResult>
+ filters : typing.Sequence[~StorageFilter]
+ Returns -> typing.Sequence[~StorageDetailsListResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Storage', request='ListStorageDetails', version=3, params=_params)
+ msg = dict(type='Storage',
+ request='ListStorageDetails',
+ version=3,
+ params=_params)
_params['filters'] = filters
reply = await self.rpc(msg)
return reply
@ReturnMapping(VolumeDetailsListResults)
async def ListVolumes(self, filters):
'''
- filters : typing.Sequence<+T_co>[~VolumeFilter]<~VolumeFilter>
- Returns -> typing.Sequence<+T_co>[~VolumeDetailsListResult]<~VolumeDetailsListResult>
+ filters : typing.Sequence[~VolumeFilter]
+ Returns -> typing.Sequence[~VolumeDetailsListResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Storage', request='ListVolumes', version=3, params=_params)
+ msg = dict(type='Storage',
+ request='ListVolumes',
+ version=3,
+ params=_params)
_params['filters'] = filters
reply = await self.rpc(msg)
return reply
@ReturnMapping(StorageDetailsResults)
async def StorageDetails(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StorageDetailsResult]<~StorageDetailsResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StorageDetailsResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='Storage', request='StorageDetails', version=3, params=_params)
+ msg = dict(type='Storage',
+ request='StorageDetails',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(LifeResults)
async def AttachmentLife(self, ids):
'''
- ids : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
- Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
+ ids : typing.Sequence[~MachineStorageId]
+ Returns -> typing.Sequence[~LifeResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='AttachmentLife', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='AttachmentLife',
+ version=3,
+ params=_params)
_params['ids'] = ids
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def EnsureDead(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='EnsureDead', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='EnsureDead',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(FilesystemAttachmentParamsResults)
async def FilesystemAttachmentParams(self, ids):
'''
- ids : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
- Returns -> typing.Sequence<+T_co>[~FilesystemAttachmentParamsResult]<~FilesystemAttachmentParamsResult>
+ ids : typing.Sequence[~MachineStorageId]
+ Returns -> typing.Sequence[~FilesystemAttachmentParamsResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='FilesystemAttachmentParams', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='FilesystemAttachmentParams',
+ version=3,
+ params=_params)
_params['ids'] = ids
reply = await self.rpc(msg)
return reply
@ReturnMapping(FilesystemAttachmentResults)
async def FilesystemAttachments(self, ids):
'''
- ids : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
- Returns -> typing.Sequence<+T_co>[~FilesystemAttachmentResult]<~FilesystemAttachmentResult>
+ ids : typing.Sequence[~MachineStorageId]
+ Returns -> typing.Sequence[~FilesystemAttachmentResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='FilesystemAttachments', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='FilesystemAttachments',
+ version=3,
+ params=_params)
_params['ids'] = ids
reply = await self.rpc(msg)
return reply
@ReturnMapping(FilesystemParamsResults)
async def FilesystemParams(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~FilesystemParamsResult]<~FilesystemParamsResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~FilesystemParamsResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='FilesystemParams', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='FilesystemParams',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(FilesystemResults)
async def Filesystems(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~FilesystemResult]<~FilesystemResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~FilesystemResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='Filesystems', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='Filesystems',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringResults)
async def InstanceId(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StringResult]<~StringResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StringResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='InstanceId', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='InstanceId',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(LifeResults)
async def Life(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~LifeResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='Life', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='Life',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def Remove(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='Remove', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='Remove',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def RemoveAttachment(self, ids):
'''
- ids : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ ids : typing.Sequence[~MachineStorageId]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='RemoveAttachment', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='RemoveAttachment',
+ version=3,
+ params=_params)
_params['ids'] = ids
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def SetFilesystemAttachmentInfo(self, filesystem_attachments):
'''
- filesystem_attachments : typing.Sequence<+T_co>[~FilesystemAttachment]<~FilesystemAttachment>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ filesystem_attachments : typing.Sequence[~FilesystemAttachment]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='SetFilesystemAttachmentInfo', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='SetFilesystemAttachmentInfo',
+ version=3,
+ params=_params)
_params['filesystem-attachments'] = filesystem_attachments
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def SetFilesystemInfo(self, filesystems):
'''
- filesystems : typing.Sequence<+T_co>[~Filesystem]<~Filesystem>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ filesystems : typing.Sequence[~Filesystem]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='SetFilesystemInfo', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='SetFilesystemInfo',
+ version=3,
+ params=_params)
_params['filesystems'] = filesystems
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>
+ entities : typing.Sequence[~EntityStatusArgs]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='SetStatus', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='SetStatus',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def SetVolumeAttachmentInfo(self, volume_attachments):
'''
- volume_attachments : typing.Sequence<+T_co>[~VolumeAttachment]<~VolumeAttachment>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ volume_attachments : typing.Sequence[~VolumeAttachment]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='SetVolumeAttachmentInfo', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='SetVolumeAttachmentInfo',
+ version=3,
+ params=_params)
_params['volume-attachments'] = volume_attachments
reply = await self.rpc(msg)
return reply
@ReturnMapping(ErrorResults)
async def SetVolumeInfo(self, volumes):
'''
- volumes : typing.Sequence<+T_co>[~Volume]<~Volume>
- Returns -> typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ volumes : typing.Sequence[~Volume]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='SetVolumeInfo', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='SetVolumeInfo',
+ version=3,
+ params=_params)
_params['volumes'] = volumes
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>
+ entities : typing.Sequence[~EntityStatusArgs]
+ Returns -> typing.Sequence[~ErrorResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='UpdateStatus', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='UpdateStatus',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(VolumeAttachmentParamsResults)
async def VolumeAttachmentParams(self, ids):
'''
- ids : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
- Returns -> typing.Sequence<+T_co>[~VolumeAttachmentParamsResult]<~VolumeAttachmentParamsResult>
+ ids : typing.Sequence[~MachineStorageId]
+ Returns -> typing.Sequence[~VolumeAttachmentParamsResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='VolumeAttachmentParams', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='VolumeAttachmentParams',
+ version=3,
+ params=_params)
_params['ids'] = ids
reply = await self.rpc(msg)
return reply
@ReturnMapping(VolumeAttachmentResults)
async def VolumeAttachments(self, ids):
'''
- ids : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
- Returns -> typing.Sequence<+T_co>[~VolumeAttachmentResult]<~VolumeAttachmentResult>
+ ids : typing.Sequence[~MachineStorageId]
+ Returns -> typing.Sequence[~VolumeAttachmentResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='VolumeAttachments', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='VolumeAttachments',
+ version=3,
+ params=_params)
_params['ids'] = ids
reply = await self.rpc(msg)
return reply
@ReturnMapping(BlockDeviceResults)
async def VolumeBlockDevices(self, ids):
'''
- ids : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
- Returns -> typing.Sequence<+T_co>[~BlockDeviceResult]<~BlockDeviceResult>
+ ids : typing.Sequence[~MachineStorageId]
+ Returns -> typing.Sequence[~BlockDeviceResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='VolumeBlockDevices', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='VolumeBlockDevices',
+ version=3,
+ params=_params)
_params['ids'] = ids
reply = await self.rpc(msg)
return reply
@ReturnMapping(VolumeParamsResults)
async def VolumeParams(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~VolumeParamsResult]<~VolumeParamsResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~VolumeParamsResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='VolumeParams', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='VolumeParams',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(VolumeResults)
async def Volumes(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~VolumeResult]<~VolumeResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~VolumeResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='Volumes', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='Volumes',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(NotifyWatchResults)
async def WatchBlockDevices(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~NotifyWatchResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='WatchBlockDevices', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='WatchBlockDevices',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(MachineStorageIdsWatchResults)
async def WatchFilesystemAttachments(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~MachineStorageIdsWatchResult]<~MachineStorageIdsWatchResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~MachineStorageIdsWatchResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='WatchFilesystemAttachments', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='WatchFilesystemAttachments',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringsWatchResults)
async def WatchFilesystems(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StringsWatchResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='WatchFilesystems', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='WatchFilesystems',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(NotifyWatchResults)
async def WatchMachines(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~NotifyWatchResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='WatchMachines', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='WatchMachines',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(MachineStorageIdsWatchResults)
async def WatchVolumeAttachments(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~MachineStorageIdsWatchResult]<~MachineStorageIdsWatchResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~MachineStorageIdsWatchResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='WatchVolumeAttachments', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='WatchVolumeAttachments',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
@ReturnMapping(StringsWatchResults)
async def WatchVolumes(self, entities):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
- Returns -> typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
+ entities : typing.Sequence[~Entity]
+ Returns -> typing.Sequence[~StringsWatchResult]
'''
# map input types to rpc msg
_params = dict()
- msg = dict(type='StorageProvisioner', request='WatchVolumes', version=3, params=_params)
+ msg = dict(type='StorageProvisioner',
+ request='WatchVolumes',
+ version=3,
+ params=_params)
_params['entities'] = entities
reply = await self.rpc(msg)
return reply
projects / osm / N2VC.git / blobdiff