def sshkey(): handler = request_handler.SSHKey_Handler() handler.authenticate(fromRequestHeaders('Apikey', request)) requestBody = { 'GET': RequestBody(), 'POST': RequestBody(request.data) }[request.method] requestBody.put("applicationName", fromRequestHeaders('Applicationname', request)) response = { 'GET': handler.list_sshkey, 'POST': handler.create_sshkey, }[request.method](requestBody) return response
def delete_database(self, applicationName=None, deploymentName=None, databaseName=None, requestBody=RequestBody()): redistogo = 'redistogo:nano' try: response = self._http_resource(method='DELETE', resource=('apps', applicationName, 'addons', redistogo)) if response.ok: return wrapResponseMessage({ 'database': { 'databaseName': redistogo, 'userName': '', 'password': '', 'host': '', 'port': '', }, 'message': 'success' }) else: return wrapResponseMessage({'message': response.reason}), 500 except requests.exceptions.HTTPError, he: e = Exception(he.response.text) if hasattr(he.response, 'status_code'): e.status = he.response.status_code raise e
def list_application(self, requestBody=RequestBody()): try: herokuApps = self.apps applicationList = [] for application in herokuApps: applicationModel = dict({ 'applicationName': application.name, 'created': application.created_at.isoformat(), 'modified': None, 'repository': None, 'language': None }) applicationList.append(applicationModel) return wrapResponseMessage(dict(applications=applicationList)) except requests.exceptions.HTTPError, he: e = Exception(he.response.text) if hasattr(he.response, 'status_code'): e.status = he.response.status_code raise e
def application(self, applicationName=None, requestBody=RequestBody()): try: response = self._http_resource(method='GET', resource=('apps', applicationName)) if response.ok: response = response.json application = dict({ 'applicationName': response['name'] if 'name' in response else None, 'created': response['created_at'] if 'created_at' in response else None, 'repository': response['git_url'] if 'git_url' in response else None, 'modified': response['updated_at'] if 'updated_at' in response else None, 'language': response['buildpack_provided_description'] if 'buildpack_provided_description' in response else None }) return wrapResponseMessage({'application': application}) else: return wrapResponseMessage({'message': response.reason}), 500 except requests.exceptions.HTTPError, he: e = Exception(he.response.text) if hasattr(he.response, 'status_code'): e.status = he.response.status_code raise e
def operation(self, applicationName=None, operation=None, requestBody=RequestBody()): try: if operation in self.valid_operations: message = 'success' if not operation is "nop": state = { 'start': "0", 'stop': "1", }[operation] response = self._http_resource( method='POST', resource=('apps', applicationName, 'server/maintenance'), params={ 'app': applicationName, 'maintenance_mode': state }, data={ 'app': applicationName, 'maintenance_mode': state }) if not response.ok: message = response.text return wrapResponseMessage({'message': message}) else: return wrapResponseMessage({'message': 'Bad Request'}), 400 except Exception, e: return wrapResponseMessage(e)
def delete_sshkey(self, requestBody=RequestBody()): applicationName = requestBody.get('applicationName') sshKey = requestBody.get('sshKey') if applicationName and sshKey: app = self.read_app(applicationName) username = app['users'][0]['username'] keys = self.read_user_keys(username) deleted = False for key_id_ob in keys: key_object = self.read_user_key(username, key_id_ob['key_id']) affectedKey = key_object['key'] if affectedKey == sshKey: deleted = self.delete_user_key(username, key_id_ob['key_id']) break if deleted: sshKey = dict({ 'sshKey': sshKey, 'owner': app['users'][0]['email'] }) return wrapResponseMessage(dict(sshKey=sshKey)), 204 else: raise GoneError() else: return wrapResponseMessage("Bad Request"), 400
def delete_sshkey(): handler = request_handler.SSHKey_Handler() handler.authenticate(fromRequestHeaders('Apikey', request)) requestBody = RequestBody(request.data) requestBody.put("sshKey", fromRequestHeaders('SshKey', request)) requestBody.put("applicationName", fromRequestHeaders('Applicationname', request)) return handler.delete_sshkey(requestBody)
def sshkey(): try: handler = request_handler.SSHKey_Handler() handler.authenticate(fromRequestHeaders('Apikey',request)) requestBody = { 'GET' : RequestBody(), 'POST' : RequestBody(request.data) }[request.method] response = { 'GET': handler.list_sshkey, 'POST': handler.create_sshkey, }[request.method](requestBody) return response.status_code if type(response) is requests.models.Response else response except Exception, e: return wrapResponseMessage(e), extractStatusCode(e)
def c4s(self, requestBody=RequestBody()): return wrapResponseMessage({ 'module': { 'description': 'cloud4soa', 'version': '1.0', 'moduleName': '' } })
def ems(self, requestBody=RequestBody()): return wrapResponseMessage({ 'module': { 'description': 'cloud4soa execution & management', 'version': '1.0', 'moduleName': 'ems' } })
def monitor(self, requestBody=RequestBody()): return wrapResponseMessage({ 'module': { 'description': 'cloud4soa monitoring', 'version': '1.0', 'moduleName': 'monitor' } })
def delete_deployment(self, applicationName=None, deploymentName=None, requestBody=RequestBody()): try: return wrapResponseMessage({'message': '501 Not implemented'}), 501 except Exception, e: return wrapResponseMessage(e)
def create_sshkey(self, requestBody=RequestBody()): sshKey = requestBody.get('sshKey') if sshKey: user = self.read_users()[0] self.create_user_key(user['username'], sshKey) sshKey = dict({'sshKey': sshKey, 'owner': user['email']}) return wrapResponseMessage(dict(sshKey=sshKey)), 201 else: return wrapResponseMessage("Bad Request"), 400
def list_application(): try: handler = request_handler.Application_Handler() handler.authenticate(request.headers['Apikey']) response = handler.list_application(RequestBody(request.data)) return response.status_code if type(response) is requests.models.Response else response except Exception, e: return wrapResponseMessage(e), extractStatusCode(e)
def application(application): handler = request_handler.Application_Handler() handler.authenticate(request.headers['Apikey']) response = { 'POST': handler.create_application, 'PUT': handler.update_application, 'GET': handler.application, 'DELETE': handler.delete_application }[request.method](application, RequestBody(request.data)) return response
def application(self, applicationName=None, requestBody=RequestBody()): application = self.read_app(applicationName) app = dict({ 'applicationName': application['name'], 'created': application['date_created'], 'modified': application['date_modified'], 'repository': application['repository'], 'language': application['type']['name'] }) return wrapResponseMessage({'application': app}), 200
def delete_sshkey(): try: handler = request_handler.SSHKey_Handler() handler.authenticate(fromRequestHeaders('Apikey', request)) requestBody = RequestBody() requestBody.put("sshKey", fromRequestHeaders('SshKey', request)) return handler.delete_sshkey(requestBody) except Exception, e: return wrapResponseMessage(e), extractStatusCode(e)
def create_sshkey(self, requestBody=RequestBody()): sshKey = requestBody.get('sshKey') if not sshKey is None: newKey = heroku.models.Key() newKey._h = self newKey = newKey.new(sshKey) sshKey = dict({'sshKey': newKey.contents, 'owner': newKey.email}) return wrapResponseMessage(dict(sshKey=sshKey)) else: return wrapResponseMessage(Exception('Bad Request')), 400
def list_database(self, applicationName=None, deploymentName=None, requestBody=RequestBody()): try: #redistogo:nano response = self._get_resource(resource=('apps', applicationName), obj=heroku.models.App) redis = response.addons.get('redistogo:nano') return wrapResponseMessage({'message': '501 Not implemented'}), 501 except Exception, e: return wrapResponseMessage(e)
def list_deployment(self, applicationName=None, requestBody=RequestBody()): app = self.read_app(applicationName) deploymentList = [] for dep in app['deployments']: deployment = self.read_deployment(applicationName, dep) deployment = dict({ 'applicationName': applicationName, 'deploymentName': deployment['name'], 'subdomain': deployment['default_subdomain'], 'state': deployment['state'] }) deploymentList.append(deployment) return wrapResponseMessage(dict(deployments=deploymentList)), 200
def deployment(self, applicationName=None, deploymentName=None, requestBody=RequestBody()): deployment = self.read_deployment(applicationName, deploymentName) return wrapResponseMessage({ 'deployment': { 'applicationName': applicationName, 'deploymentName': deploymentName, 'subdomain': deployment['default_subdomain'], 'state': deployment['state'] } }), 200
def c4s(): try: handler = request_handler.Common_Handler() ''' If we need authentication here, we should enable this, otherwise not ''' #handler.authenticate(request.headers["Apikey"]) response = handler.c4s(RequestBody(request.data)) return response.status_code if type(response) is requests.models.Response else response except Exception, e: return wrapResponseMessage(e), extractStatusCode(e)
def database(self, applicationName=None, deploymentName=None, databaseName=None, requestBody=RequestBody()): redistogo = 'redistogo:nano' try: response = self._http_resource(method='GET', resource=('apps', applicationName, 'addons', redistogo)) return wrapResponseMessage({'message': '501 Not implemented'}), 501 except Exception, e: return wrapResponseMessage(e)
def list_sshkey(self, requestBody=RequestBody()): response = self._http_resource(method='GET', resource=('user', 'keys')) if response.ok: sshKeys = response.json sshKeysList = [] for sshKey in sshKeys: sshKey = dict({ 'sshKey': sshKey['contents'], 'owner': sshKey['email'] }) sshKeysList.append(sshKey) return wrapResponseMessage(dict(sshKeys=sshKeysList)) else: return wrapResponseMessage({'message': response.reason}), 500
def delete_application(self, applicationName=None, requestBody=RequestBody()): try: herokuApps = self.apps for application in herokuApps: if application.name == applicationName: try: response = application.destroy() return wrapResponseMessage({'message': response}) except Exception, e: return wrapResponseMessage(e) return wrapResponseMessage({'message': 'Not found.'}), 404
def create_application(self, applicationName=None, requestBody=RequestBody()): app = self.create_app(applicationName, requestBody.get('language'), 'git') return wrapResponseMessage( dict( application={ 'applicationName': app['name'], 'created': app['date_created'], 'url': '{}.cloudcontrolled.com'.format(app['name']), 'modified': app['date_modified'], 'repository': app['repository'], 'language': app['type']['name'] })), 201
def delete_dep(self, applicationName=None, deploymentName=None, requestBody=RequestBody()): deployment = self.read_deployment(applicationName, deploymentName) deleted = self.delete_deployment(applicationName, deploymentName) return wrapResponseMessage({ 'deployment': { 'applicationName': applicationName, 'deploymentName': deploymentName, 'subdomain': deployment['default_subdomain'], 'state': 'not deploymend' if deleted else 'deployed' }, 'message': 'success' }), 204
def create_database(self, applicationName=None, deploymentName=None, databaseName=None, requestBody=RequestBody()): addonName = 'mysqls.free' mysqls_instance = self.create_addon(applicationName, deploymentName, addonName) return wrapResponseMessage({ 'database': { 'databaseName': mysqls_instance['settings']['MYSQLS_DATABASE'], 'userName': mysqls_instance['settings']['MYSQLS_USERNAME'], 'password': mysqls_instance['settings']['MYSQLS_PASSWORD'], 'host': mysqls_instance['settings']['MYSQLS_HOSTNAME'], 'port': mysqls_instance['settings']['MYSQLS_PORT'] } }), 201
def list_sshkey(self, requestBody=RequestBody()): applicationName = requestBody.get('applicationName') if applicationName: app = self.read_app(applicationName) users = app['users'] user = users[0] keys = self.read_user_keys(user['username']) sshKeysList = [] for key in keys: affectedKey = self.read_user_key(user['username'], key['key_id']) sshKey = dict({ 'sshKey': affectedKey['key'], 'owner': user['email'] }) sshKeysList.append(sshKey) return wrapResponseMessage(dict(sshKeys=sshKeysList)), 200 else: return wrapResponseMessage("Bad Request"), 400
def delete_sshkey(self, requestBody=RequestBody()): sshKey = requestBody.get('sshKey') if not sshKey is None: key_id = sshKey.split()[-1] affectedKey = self.keys.get(key_id) if not affectedKey is None: affectedKey.delete() sshKey = dict({ 'sshKey': affectedKey.contents, 'owner': affectedKey.email }) return wrapResponseMessage(dict(sshKey=sshKey)) else: return wrapResponseMessage(Exception('Gone')), 410 else: return wrapResponseMessage(Exception('Bad Request')), 400