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 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 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_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 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_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 set_container_ru(self, dbname, cname, ru): print('set_container_ru: {} {} {}'.format(dbname, cname, ru)) associations = self.associate_offers(dbname) for a in associations: if (a['type'] == 'coll') and (a['name'] == cname): offer = a['offer'] print(json.dumps(offer, sort_keys=False, indent=2)) offer['content'][ 'offerThroughput'] = ru # update the offer JSON with new RU print(json.dumps(offer, sort_keys=False, indent=2)) # See https://docs.microsoft.com/en-us/rest/api/cosmos-db/replace-an-offer offer_id = a['offer']['id'] resource = a['offer']['resource'] offerResourceId = a['offer']['offerResourceId'] id = a['offer']['id'] rid = a['offer']['_rid'] body = RequestBody.replace_container_offer( ru, resource, offerResourceId, id, rid) print(body) verb, resource_link = 'put', '{}'.format(offer_id) headers = self.__rest_headers(verb, 'offers', resource_link) url = 'https://{}.documents.azure.com/offers/{}'.format( self.cosmos_acct, offer_id) return self.__execute_http_request('replace_offer', verb, url, headers, body)
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 delete_deployment(self, applicationName=None, deploymentName=None, requestBody=RequestBody()): try: return wrapResponseMessage({'message': '501 Not implemented'}), 501 except Exception, e: return wrapResponseMessage(e)
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 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 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 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 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 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 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 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 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 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 create_database(self, dbname, autopilot_ru): # See https://docs.microsoft.com/en-us/rest/api/cosmos-db/create-a-database print('create_database: {} {}'.format(dbname, autopilot_ru)) verb, resource_link = 'post', '' headers = self.__rest_headers(verb, 'dbs', resource_link) if autopilot_ru > 0: settings = {"maxThroughput": autopilot_ru} headers['x-ms-cosmos-offer-autopilot-settings'] = json.dumps( settings) body = RequestBody.create_db(dbname) print(headers) print(body) url = 'https://{}.documents.azure.com/dbs'.format(self.cosmos_acct) return self.__execute_http_request('create_database', verb, url, headers, body)
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_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 create_container(self, dbname, cname, ru, pk): # See https://docs.microsoft.com/en-us/rest/api/cosmos-db/create-a-collection print('create_container: {} {} {} {}'.format(dbname, cname, ru, pk)) verb, resource_link = 'post', 'dbs/{}'.format(dbname) headers = self.__rest_headers(verb, 'colls', resource_link) body = RequestBody.create_container(cname, pk) if ru > 0: headers['x-ms-offer-throughput'] = str(ru) url = 'https://{}.documents.azure.com/dbs/{}/colls'.format( self.cosmos_acct, dbname) print(json.dumps(headers, sort_keys=False, indent=2)) print(json.dumps(body, sort_keys=False, indent=2)) print(url) return self.__execute_http_request('create_container', verb, url, headers, body)