def schedule_workflow(self, name, timestamp, parameters=None):
if not parameters: parameters = {}
log.info("Scheduling workflow %s on instance %s (%s), timestamp: %s" % (name, self.name, self.id, timestamp))
log.debug("Parameters: %s" % parameters)
payload = {'parameters': parameters, 'timestamp':timestamp}
router.post_instance_workflow_schedule(org_id=self.organizationId, instance_id=self.instanceId, wf_name=name, data=json.dumps(payload))
return True
def run_workflow(self, name, parameters=None):
if not parameters: parameters = {}
log.info("Running workflow %s on instance %s (%s)" % (name, self.name, self.id))
log.debug("Parameters: %s" % parameters)
self._last_workflow_started_time = time.gmtime(time.time())
router.post_instance_workflow(org_id=self.organizationId, instance_id=self.instanceId, wf_name=name, data=json.dumps(parameters))
return True
def add_as_service(self, environments=None, environment_ids=None):
if not environments or environment_ids:
# Use default if not set
environments = [self.environment,]
if environments:
data = [env.environmentId for env in environments]
else:
assert isinstance(environment_ids, list)
data = environment_ids
router.post_instance_services(org_id=self.organizationId, instance_id=self.instanceId, data=json.dumps(data))
def connect(tenant, user, password):
router.base_url = tenant
router.connect(user, password)
#todo: remove auth mimics when routes are used everywhere
router.tenant = tenant
router.user = user
router.password = password
return QubellPlatform(auth=router)
def get_activitylog(self, after=None, severity=None, start=None, end=None):
"""
Returns activitylog object
severity - filter severity ('INFO', DEBUG')
start/end - time or log text
"""
if after:
log = router.get_instance_activitylog(org_id=self.organizationId, instance_id=self.instanceId, timestamp=after).json()
log = router.get_instance_activitylog(org_id=self.organizationId, instance_id=self.instanceId).json()
return activityLog(log, severity=severity, start=start, end=end)
def new(application, revision=None, environment=None, name=None, parameters=None, submodules=None, destroyInterval=None):
if not environment:
environment = application.organization.defaultEnvironment
if not parameters: parameters = {}
conf = {}
conf['parameters'] = parameters
conf['environmentId'] = environment.environmentId
if name:
conf['instanceName'] = name
if destroyInterval:
conf['destroyInterval'] = destroyInterval
if revision:
conf['revisionId'] = revision.id
conf['submodules'] = submodules or {}
log.info("Starting instance: %s\n Application: %s (%s)\n Environment: %s (%s)\n Submodules: %s\n destroyInterval: %s" %
(name,
application.name, application.applicationId,
environment.name, environment.environmentId,
submodules, destroyInterval))
log.debug("Instance configuration: %s" % conf)
data = json.dumps(conf)
before_creation = time.gmtime(time.time())
resp = router.post_organization_instance(org_id=application.organizationId, app_id=application.applicationId, data=data)
instance = Instance(organization=application.organization, id=resp.json()['id'])
instance._last_workflow_started_time = before_creation
log.debug("Instance %s (%s) started." % (instance.name, instance.id))
return instance
def update(self, **kwargs):
if kwargs.get('manifest'):
self.upload(kwargs.pop('manifest'))
log.info("Updating application: %s" % self.name)
data = json.dumps(kwargs)
resp = router.put_application(org_id=self.organizationId, app_id=self.applicationId, data=data)
return resp.json()
def list_instances_json(self, application=None):
""" Get list of instances in json format converted to list"""
if application: # todo: application should not be parameter here. Application should do its own list
warnings.warn("organization.list_instances_json(app) is deprecated, use app.list_instances_json", DeprecationWarning, stacklevel=2)
instances = application.list_instances_json()
else: # Return all instances in organization
instances = router.get_instances(org_id=self.organizationId).json()
return [ins for ins in instances if ins['status'] not in DEAD_STATUS]
def new(organization, name, manifest):
log.info("Creating application: %s" % name)
resp = router.post_organization_application(org_id=organization.organizationId,
files={'path': manifest.content},
data={'manifestSource': 'upload', 'name': name})
app = Application(organization, resp.json()['id'])
app.manifest = manifest
return app
def new(organization, name, zone=None, default=False):
log.info("Creating environment: %s" % name)
if not zone:
zone = organization.zone.zoneId
data = {'isDefault': default,
'name': name,
'backend': zone,
'organizationId': organization.organizationId}
resp = router.post_organization_environment(org_id=organization.organizationId, data=json.dumps(data)).json()
return Environment(organization, id=resp['id'])
def json(self):
'''
return __cached_json, if accessed withing 300 ms.
This allows to optimize calls when many parameters of entity requires withing short time.
'''
if self.fresh():
return self.__cached_json
self.__last_read_time = time.time()
self.__cached_json = router.get_instance(org_id=self.organizationId, instance_id=self.instanceId).json()
return self.__cached_json
def create_revision(self, name, instance, parameters=[], version=None):
if not version:
version=self.get_manifest()['manifestVersion']
payload = json.dumps({ 'name': name,
'parameters': parameters,
'submoduleRevisions': {},
'returnValues': [],
'applicationId': self.applicationId,
'applicationName': self.name,
'version': version,
'instanceId': instance.instanceId})
resp = router.post_revision(org_id=self.organizationId, app_id=self.applicationId, data=payload)
return self.get_revision(id=resp.json()['id'])
def new(organization, name, zone_id=None, default=False):
log.info("Creating environment: %s" % name)
if not zone_id:
zone_id = organization.zone.zoneId
data = {'isDefault': default,
'name': name,
'backend': zone_id,
'organizationId': organization.organizationId}
log.debug(data)
resp = router.post_organization_environment(org_id=organization.organizationId, data=json.dumps(data)).json()
env = Environment(organization, id=resp['id'])
log.info("Environment created: %s (%s)" % (name,env.environmentId))
return env
def reconfigure(self, revision=None, parameters=None, submodules=None):
#note: be carefull refactoring this, or you might have unpredictable results
#todo: private api seems requires at least presence of submodule names if exist
payload = {}
payload['parameters'] = self.parameters
if revision:
payload['revisionId'] = revision.id
if submodules:
payload['submodules'] = submodules
if parameters is not None:
payload['parameters'] = parameters
resp = router.put_instance_configuration(org_id=self.organizationId, instance_id=self.instanceId, data=json.dumps(payload))
return resp.json()
def new(application, revision=None, environment=None, name=None, parameters=None, destroyInterval=None):
if not parameters: parameters = {}
if environment: # if environment set, it overrides parameter
parameters['environmentId'] = environment.environmentId
elif not 'environmentId' in parameters.keys(): # if not set and not in params, use default
parameters['environmentId'] = application.organization.defaultEnvironment.environmentId
if name:
parameters['instanceName'] = name
if destroyInterval:
parameters['destroyInterval'] = str(destroyInterval)
if revision:
parameters['revisionId'] = revision.revisionId
data = json.dumps(parameters)
before_creation = time.gmtime(time.time())
resp = router.post_organization_instance(org_id=application.organizationId, app_id=application.applicationId, data=data)
instance = Instance(organization=application.organization, id=resp.json()['id'])
instance._last_workflow_started_time = before_creation
return instance
def json(self):
return router.get_revision(org_id=self.organizationId, app_id=self.applicationId, rev_id=self.revisionId).json()
def delete(self):
router.delete_revision(org_id=self.organizationId, app_id=self.applicationId, rev_id=self.revisionId)
return True
def authenticate(self):
router.base_url = self.auth.tenant
router.connect(self.auth.user, self.auth.password)
#todo: remove following, left for compatibility
self.auth.cookies = router._cookies
return True
def list_organizations_json(self):
resp = router.get_organizations()
return resp.json()
def reschedule_workflow(self, workflow_id, timestamp):
log.info("ReScheduling workflow %s on instance %s (%s), timestamp: %s" % (workflow_id, self.name, self.id, timestamp))
payload = {'timestamp':timestamp}
router.post_instance_reschedule(org_id=self.organizationId, instance_id=self.instanceId, workflow_id=workflow_id, data=json.dumps(payload))
return True
def regenerate(self):
return router.post_service_generate(org_id=self.organizationId, instance_id=self.instanceId).json()
def force_remove(self):
return router.delete_instance_force(org_id=self.organizationId, instance_id=self.instanceId)
def delete(self):
log.info("Removing application: %s" % self.name)
router.delete_application(org_id=self.organizationId, app_id=self.applicationId)
return True
def upload(self, manifest):
log.info("Uploading manifest")
self.manifest = manifest
return router.post_application_manifest(org_id=self.organizationId, app_id=self.applicationId,
files={'path': manifest.content},
data={'manifestSource': 'upload', 'name': self.name}).json()
def get_manifest(self):
return router.post_application_refresh(org_id=self.organizationId, app_id=self.applicationId).json()
def cancel_command(self):
return router.post_instance_action(org_id=self.organizationId, instance_id=self.instanceId, action="cancel")
def unstar(self):
return router.post_instance_action(org_id=self.organizationId, instance_id=self.instanceId, action="unstar")
def json(self):
resp = router.get_providers(org_id=self.organizationId)
provider = [x for x in resp.json() if x['id'] == self.providerId]
if len(provider)>0:
return provider[0]
def delete(self):
router.delete_provider(org_id=self.organizationId,prov_id=self.providerId)
return True
def rename(self, name):
payload = json.dumps({'instanceName': name})
return router.put_instance_configuration(org_id=self.organizationId, instance_id=self.instanceId, data=payload)
