def exec_update_sql_dict(self, query, args=None): self.get_cursor() try: self.cursor.execute(query=query, args=args) self.conn.commit() self.cursor.close() self.conn.close() log.debug('exec sql success, sql=%s' % (str(query))) return except Exception, e: try: self.cursor.execute(query=query, args=args) self.conn.commit() self.cursor.close() self.conn.close() log.debug('exec sql success, sql=%s' % (str(query))) return except Exception, e: log.error('exec sql error, sql=%s, reason=%s' % (str(query), e)) self.cursor.close() self.conn.close() raise
def templet_delete(self, context, templet_uuid): log.debug('delete the templet, the context is: %s' % context) try: parameter_check(templet_uuid, exist='yes') except Exception, e: log.error('parameters error, reason is: %s' % e) return request_result(101)
def exec_update_sql(self, *sql): self.get_cursor() try: for v_sql in sql: self.cursor.execute(v_sql) self.conn.commit() self.cursor.close() self.conn.close() log.debug('exec sql success, sql=%s' % (str(sql))) return except Exception, e: try: for v_sql in sql: self.cursor.execute(v_sql) self.conn.commit() self.cursor.close() self.conn.close() log.debug('exec sql success, sql=%s' % (str(sql))) return except Exception, e: log.error('exec sql error, sql=%s, reason=%s' % (str(sql), e)) self.cursor.close() self.conn.close() raise
def snap_create(self, context, parameters): try: token = context['token'] source_ip = context.get('source_ip') user_info = token_auth(context['token'])['result'] user_uuid = user_info.get('user_uuid') team_uuid = user_info.get('team_uuid') project_uuid = user_info.get('project_uuid') log.debug('the token is: %s, source_ip is: %s, user_uuid is: %s,' 'team_uuid is: %s, project_uuid is: %s' % (token, source_ip, user_uuid, team_uuid, project_uuid)) name = parameters.get('name') description = parameters.get('description') metadata = parameters.get('metadata') volume_uuid = parameters.get('volume_uuid') vm_uuid = parameters.get('vm_uuid') parameter_check(name, ptype='pnam') except Exception, e: log.error('parameters error, reason is: %s' % e) return request_result(101)
def mq_connect(self, mq_server01=conf.mq_server01, mq_server02=conf.mq_server02, mq_port=conf.mq_port, heartbeat_time=30): log.debug('Connecting to rabbitmq server, server01=%s, server02=%s' % (mq_server01, mq_server02)) try: self.connection = pika.BlockingConnection( pika.ConnectionParameters( host=mq_server01, port=mq_port, heartbeat_interval=heartbeat_time)) self.channel = self.connection.channel() except Exception, e: log.error('RabbitMQ server %s connection error: reason=%s' % (mq_server01, e)) try: self.connection = pika.BlockingConnection( pika.ConnectionParameters( host=mq_server02, port=mq_port, heartbeat_interval=heartbeat_time)) self.channel = self.connection.channel() except Exception, e: log.error('RabbitMQ server %s connection error: reason=%s' % (mq_server02, e)) raise
def snap_delete(self, context, snapshot_uuid, logic=0): log.debug('delete the snapshot, context is: %s' % context) if logic == 0: return self.snap_manager.delete(snapshot_uuid) if logic == 1: return self.snap_manager.logic_delete(snapshot_uuid) return request_result(1003)
def volume_delete(self, context, parameters): log.debug('delete context is: %s' % context) try: volume_uuid = parameters.get('volume_uuid') logic = parameters.get('logic') if logic is None: logic = 1 except Exception, e: log.error('parameters check error, reason is: %s' % e) return request_result(101)
def rc_status_info(self, token=None): try: r = requests.get(self.get_pod_status_url, headers=self.headers, verify=False, timeout=5) log.debug('rc_status=%s' % r.text) return request_result(0, r.text) except Exception, e: log.error('requests k8s api error, reason=%s' % e) return request_result(103)
def __aclauth(*args, **kwargs): func_args = inspect.getcallargs(func, *args, **kwargs) context = func_args.get('context') token = context['token'] resources_uuid = context['resource_uuid'] action = context['action'] user_info = token_auth(token)['result'] user_uuid = user_info['user_uuid'] team_uuid = user_info['team_uuid'] team_priv = user_info['team_priv'] project_uuid = user_info['project_uuid'] project_priv = user_info['project_priv'] context = "%s%s%s%s%s%s%s" % (user_uuid, team_uuid, team_priv, project_uuid, project_priv, resources_uuid, action) log.debug('start ack check, context=%s' % (context)) acl_info = caches.get(context) for resource_uuid in resources_uuid: if (acl_info is LocalCache.notFound): log.debug('Cache acl not hit, context=%s' % (context)) auth_manager = AuthManager(service_name) ret = auth_manager.resource_acl_check( user_uuid, team_uuid, team_priv, project_uuid, project_priv, resource_uuid, action) expire = int(time.time()) + 300 caches.set(context, {"acl_check": ret, "expire": expire}) log.debug('Cached acl check, context=%s' % (context)) else: log.debug('Cache acl hit, context=%s' % (context)) ret = acl_info['acl_check'] log.debug('ack check result=%s' % (ret)) if ret == 0: try: return func(*args, **kwargs) except Exception, e: log.error('function(%s) exec error, reason = %s' % (func.__name__, e)) return request_result(999) else: log.warning('Resource acl auth denied: user_uuid = %s, \ team_uuid=%s, team_priv=%s, project_uuid=%s, \ project_priv=%s, resource_uuid=%s, action=%s' % (user_uuid, team_uuid, team_priv, project_uuid, project_priv, resource_uuid, action)) return request_result(202)
def app_events_es(self, project_uuid, rc_name): event = [] try: ns_events_info = self.k8s_driver.app_events_info(project_uuid) if ns_events_info.get('status') != 0: log.debug('Get events from k8s error') events_info = json.loads(ns_events_info['result']) events_list = events_info['items'] except Exception, e: log.error('get the events error, reason is: %s' % e) raise Exception('get the events error')
def exec_select_sql(self, sql): self.get_cursor() try: self.cursor.execute(sql) result = self.cursor.fetchall() self.cursor.close() self.conn.close() log.debug('exec sql success, sql=%s' % (sql)) return result except Exception, e: log.error('exec sql error, sql=%s, reason=%s' % (sql, e)) raise
def appstatus_service(): appstatus = AppStatusManager() rc_status_cache = {} while True: try: log.debug('rc_status_cache=%s' % (rc_status_cache)) rc_status_cache = appstatus.rc_status_update(rc_status_cache) except Exception, e: rc_status_cache = {} log.warning('Appstatus Service running error, reason=%s' % e) sleep(15)
def rc_status_update(self, rc_status_cache): rc_status_info = self.k8s_driver.rc_status_info() status = rc_status_info['status'] if status != 0: log.debug('Get pods status from k8s error') return rc_status_cache try: rc_status_info = json.loads(rc_status_info['result']) log.debug('rc_status_list_type=%s' % (type(rc_status_info))) rc_status_list = rc_status_info['items'] except Exception, e: log.error('Get rc status list error, reason=%s' % (e)) return rc_status_cache
class OpenstackDriver(object): def __init__(self): self.conn = connection() @staticmethod def get_token(user_name, password): header = {"Content-Type": "application/json", "Accept": "application/json"} user_msg = {"auth": {"tenantName": "cloud", "passwordCredentials": {"username": user_name, "password": password}}} try: ret = requests.post(url=conf.token_url, json=user_msg, headers=header, timeout=5) except Exception, e: log.error('get the token error, reason is: %s' % e) return request_result(501) if ret.status_code != 200: return request_result(501) log.debug('get the projectID and token(op) result is: %s' % ret.text) try: token = json.loads(ret.text).get('access').get('token').get('id') user_uuid = json.loads(ret.text).get('access').get('user').get( 'id') except Exception, e: log.error('get the token from openstack error, reason is: %s' % e) return request_result(203)
def token_auth(token): log.debug('start token check, token=%s' % (token)) token_info = caches.get(token) if (token_info is LocalCache.notFound): log.debug('Cache token auth not hit, token=%s' % (token)) try: headers = {'token': token} ret = requests.get(url, headers=headers, timeout=5).json() status = ret['status'] if status != 0: raise except Exception, e: log.error('Token ucenter auth error: reason=%s' % (e)) raise expire = int(time.time()) + 300 caches.set(token, {"token_info": ret, "expire": expire})
def token_check(self, context, parameters=None): token = context['token'] log.debug('Ucenter start token check, token=%s' % (token)) token_info = caches.get(token) if (token_info is LocalCache.notFound): log.debug('Cache token auth not hit, token=%s' % (token)) try: rpc_body = rpc_data("uct_tkn_tkn_chk", context, parameters) ret = self.rbtmq.rpc_call_client(self.queue, self.timeout, rpc_body) except Exception, e: log.error('Rpc client exec error, reason=%s' % (e)) return request_result(598) expire = int(time.time()) + 300 caches.set(token, {"token_info": ret, "expire": expire})
def token_auth(token): log.debug('start token check, token=%s' % (token)) token_info = caches.get(token) if (token_info is LocalCache.notFound): log.debug('Cache token auth not hit, token=%s' % (token)) try: context = {"token": token} ret = rpc_client.UcenterRpcClient().token_check(context) status = ret['status'] if status != 0: raise(Exception('Token auth denied')) except Exception, e: log.error('Token local auth error: reason=%s' % (e)) raise(Exception('Token auth error')) expire = int(time.time()) + 300 caches.set(token, {"token_info": ret, "expire": expire})
def __init__(self, mq_server01=conf.mq_server01, mq_server02=conf.mq_server02, mq_port=conf.mq_port): log.debug('Connecting to rabbitmq server, server01=%s, server02=%s' % (mq_server01, mq_server02)) # self.params = pika.URLParameters( # 'amqp://*****:*****@127.0.0.1:5672/?' # 'socket_timeout=10&' # 'connection_attempts=2') self.params01 = pika.ConnectionParameters(host=mq_server01, port=mq_port) self.params02 = pika.ConnectionParameters(host=mq_server02, port=mq_port) try: self.pool = pika_pool.QueuedPool( create=lambda: pika.BlockingConnection(parameters=self.params01 ), max_size=10, max_overflow=10, timeout=10, recycle=3600, stale=45) except Exception, e: log.error('rabbitmq server %s connection error: reason=%s' % (mq_server01, e)) try: self.pool = pika_pool.QueuedPool( create=lambda: pika.BlockingConnection(parameters=self. params02), max_size=10, max_overflow=10, timeout=10, recycle=3600, stale=45) except Exception, e: log.error('rabbitmq server %s connection error: reason=%s' % (mq_server02, e)) raise
def __reslmt(*args, **kwargs): try: func_args = inspect.getcallargs(func, *args, **kwargs) token = func_args.get('token') cost = func_args.get('cost') user_info = token_auth(token)['result'] team_uuid = user_info.get('team_uuid') project_uuid = user_info.get('project_uuid') user_uuid = user_info.get('user_uuid') if user_uuid != 'sysadmin': limit_info = billing_limit_check( token, resource_type, cost) balance_check = limit_info['result']['balance_check'] if int(balance_check) != 0: log.warning('Limit check denied, not enough balance') return request_result(302) limit_check = limit_info['result']['limit_check'] res_db = resources_db.ResourcesDB() resource_count = res_db.resource_count( resource_type, team_uuid, project_uuid, user_uuid) log.debug('billing_limit_check=%s, resource_count=%s' % (limit_check, resource_count)) if int(resource_count) >= int(limit_check): log.warning('Limit check denied, Team(%s) resource(%s) ' 'reach upper limit' % (team_uuid, resource_type)) return request_result(303) try: return func(*args, **kwargs) except Exception, e: log.error('function(%s) exec error, reason = %s' % (func.__name__, e)) return request_result(601) except Exception, e: log.error('Limit check error, reason=%s' % (e)) return request_result(303)
def billing_limit_check(token, resource_type, cost): try: log.debug('Start billing limit check, ' 'token=%s, resource_type=%s, cost=%s' % (token, resource_type, cost)) context = context_data(token, "bil_lmt_lmt_chk", "create") parameters = {"resource_type": resource_type, "cost": cost} limit = billing_rpcapi.BillingRpcApi().limit_check(context, parameters) log.debug('Billing limit result=%s' % (limit)) status = limit['status'] if status != 0: raise(Exception('Billing limit check error, ' 'request code not equal 0')) except Exception, e: log.error('Billing limit local check error: reason=%s' % (e)) raise(Exception('Billing limit check error'))
def attachment_create(self, context, server_uuid, volume_uuid): try: token = context['token'] source_ip = context.get('source_ip') user_info = token_auth(context['token'])['result'] user_uuid = user_info.get('user_uuid') team_uuid = user_info.get('team_uuid') project_uuid = user_info.get('project_uuid') log.debug('the token is: %s, source_ip is: %s, user_uuid is: %s,' 'team_uuid is: %s, project_uuid is: %s' % (token, source_ip, user_uuid, team_uuid, project_uuid)) parameter_check(server_uuid, exist='yes') parameter_check(volume_uuid, exist='yes') except Exception, e: log.error('parameters error, reason is: %s' % e) return request_result(101)
def token_auth(token): log.debug('start token check, token=%s' % token) token_info = caches.get(token) if token_info is LocalCache.notFound: log.debug('Cache token auth not hit, token=%s' % token) try: headers = {'token': token} ret = requests.get(url, headers=headers, timeout=5).text log.info("token confirm result is: %s(%s)" % (ret, type(ret))) ret = json.loads(ret) status = ret['status'] if status != 0: raise except Exception, e: log.error('Token ucenter auth error: reason=%s' % e) raise expire = int(time.time()) + 300 caches.set(token, {"token_info": ret, "expire": expire})
def osdisk_create(self, name, volume_uuid, v_type, image_uuid, size, conn_to, user_uuid, project_uuid, team_uuid, description='os_volume', source_volume_uuid=None, snapshot_uuid=None, is_use_domain=None, is_start=1, is_secret=0): log.debug(size) try: size = self.op_driver.image_size(image_uuid) except Exception, e: log.error('get the image size error, reason is: %s' % e) return request_result(1204)
def _tokenauth(*args, **kwargs): try: func_args = inspect.getcallargs(func, *args, **kwargs) token = func_args.get('token') if token is None: context = func_args.get('context') if context is None: for context in func_args.get('args'): if isinstance(context, dict): break token = context.get('token') log.debug('token=%s' % (token)) userinfo_auth = token_auth(token)['status'] if userinfo_auth == 0: try: result = func(*args, **kwargs) except Exception, e: log.error('function(%s) exec error, reason = %s' % (func.__name__, e)) return request_result(601) else:
def billing_limit_check(token, resource_type, cost): try: log.debug('Start billing limit check, ' 'token=%s, resource_type=%s, cost=%s' % (token, resource_type, cost)) headers = {'token': token} body = {"resource_type": resource_type, "cost": cost} limit = requests.post(limit_url, headers=headers, data=json.dumps(body), timeout=5).json() log.debug('Billing limit result=%s' % (limit)) status = limit['status'] if status != 0: raise (Exception('Billing limit check error, ' 'request code not equal 0')) except Exception, e: log.error('Billing limit local check error: reason=%s' % (e)) raise (Exception('Billing limit check error'))
def db_check_floatingip_bind(self, floatingip_uuid): sql = "select count(*) from floating_ip where uuid='%s' " \ "and vm_uuid is not NULL and vm_uuid != 'None'" % floatingip_uuid log.debug('check the floatingip bind sql is: %s' % sql) return super(NetworkDB, self).exec_select_sql(sql)
def callback_create(self): log.debug('Create callback queue') self.callback_queue = self.channel.queue_declare( exclusive=True).method.queue self.channel.basic_consume(self.on_response, queue=self.callback_queue)
def mq_disconnect(self): log.debug('Disconnect from rabbitmq server') self.channel.close() self.connection.close()
except Exception, e: log.error('add the floating ip to server(op) error, reason is: ' '%s' % e) return request_result(631) return request_result(0, op_result) def floatip_unbind(self, token, vm_uuid, floatip): try: op_result = self.conn.compute.\ remove_floating_ip_from_server(server=vm_uuid, address=floatip) except Exception, e: log.error('remove the floating ip from server(op) error, ' 'reason is: %s' % e) return request_result(632) log.debug('unbind floatip result(op) is: %s' % op_result) return request_result(0, 'removed') def vm_pwd_reset(self, token, server_uuid, new_password): try: op_result = self.conn.compute.\ change_server_password(server_uuid, new_password) except Exception, e: log.error('reset the password of the vm error, reason is: %s' % e) return request_result(641) log.info('pwd reset the result(op) is %s' % op_result) # None return request_result(0, {'server_uuid': server_uuid}) # test-code
if (token_info is LocalCache.notFound): log.debug('Cache token auth not hit, token=%s' % (token)) try: context = {"token": token} ret = rpc_client.UcenterRpcClient().token_check(context) status = ret['status'] if status != 0: raise(Exception('Token auth denied')) except Exception, e: log.error('Token local auth error: reason=%s' % (e)) raise(Exception('Token auth error')) expire = int(time.time()) + 300 caches.set(token, {"token_info": ret, "expire": expire}) else: log.debug('Cache token auth hit, token=%s' % (token)) ret = token_info['token_info'] log.debug('token_info = %s' % (ret)) return ret def token_check(func): def _tokenauth(*args, **kwargs): try: func_args = inspect.getcallargs(func, *args, **kwargs) token = func_args.get('token') if token is None: