def set_ovdc_container_provider_metadata(self, ovdc_id, container_prov_data=None, container_provider=None): """Set the container provider metadata of given ovdc. :param resource ovdc: vdc resource :param dict container_prov_data: container provider context details :param str container_provider: name of container provider for which the ovdc is being enabled to deploy k8 clusters on. """ client = None try: client = get_sys_admin_client() ovdc = get_vdc(client, vdc_id=ovdc_id) ovdc_name = ovdc.get_resource().get('name') metadata = {} metadata[K8S_PROVIDER_KEY] = container_provider or \ K8sProviders.NONE if container_provider != K8sProviders.PKS: LOGGER.debug(f"Remove existing metadata for ovdc:{ovdc_name}") self._remove_metadata_from_ovdc(ovdc, PksCache.get_pks_keys()) LOGGER.debug(f"Updated metadata for {container_provider}:" f"{metadata}") else: container_prov_data.pop('username') container_prov_data.pop('secret') container_prov_data.pop('nsxt') metadata.update(container_prov_data) # set ovdc metadata into Vcd LOGGER.debug(f"On ovdc:{ovdc_name}, setting metadata:{metadata}") return ovdc.set_multiple_metadata(metadata, MetadataDomain.SYSTEM, MetadataVisibility.PRIVATE) finally: if client: client.logout()
def _list_clusters(self): """Get list of clusters in PKS environment. :return: a list of cluster-dictionaries :rtype: list """ cluster_api = ClusterApiV1(api_client=self.client_v1) LOGGER.debug(f"Sending request to PKS: {self.pks_host_uri} " f"to list all clusters") try: clusters = cluster_api.list_clusters() except v1Exception as err: LOGGER.debug(f"Listing PKS clusters failed with error:\n {err}") raise PksServerError(err.status, err.body) list_of_cluster_dicts = [] for cluster in clusters: # TODO() Below is a temporary fix to retrieve compute_profile_name. # Expensive _get_cluster_info() call must be removed once PKS team # moves list_clusters to v1beta endpoint. v1_beta_cluster = self._get_cluster_info(cluster_name=cluster.name) # cluster_dict = { # 'name': cluster.name, # 'plan_name': cluster.plan_name, # 'uuid': cluster.uuid, # 'status': cluster.last_action_state, # 'last_action': cluster.last_action, # 'k8_master_ips': cluster.kubernetes_master_ips, # 'compute_profile_name': cluster.compute_profile_name, # 'worker_count': # cluster.parameters.kubernetes_worker_instances # } # list_of_cluster_dicts.append(cluster_dict) list_of_cluster_dicts.append(v1_beta_cluster) LOGGER.debug(f"Received response from PKS: {self.pks_host_uri} on the" f" list of clusters: {list_of_cluster_dicts}") return list_of_cluster_dicts
def find_cluster_in_org(self, cluster_name, is_org_admin_search=False): """Invoke all PKS brokers in the org to find the cluster. 'is_org_admin_search' is used here to prevent cluster creation with same cluster-name by users within org. If it is true, cluster list is filtered by the org name of the logged-in user. If cluster found: Return a tuple of (cluster and the broker instance used to find the cluster) Else: (None, None) if cluster not found. """ pks_ctx_list = \ self.create_pks_context_for_all_accounts_in_org() for pks_ctx in pks_ctx_list: pksbroker = PKSBroker(self.tenant_auth_token, self.req_spec, pks_ctx) try: return pksbroker.get_cluster_info( cluster_name=cluster_name, is_org_admin_search=is_org_admin_search), pksbroker except PksClusterNotFoundError as err: # If a cluster is not found, then broker_manager will # decide if it wants to raise an error or ignore it if was it # just scanning the broker to check if it can handle the # cluster request or not. LOGGER.debug(f"Get cluster info on {cluster_name}" f"on PKS failed with error: {err}") except PksDuplicateClusterError as err: LOGGER.debug(f"Get cluster info on {cluster_name}" f"on PKS failed with error: {err}") raise except PksServerError as err: LOGGER.debug(f"Get cluster info on {cluster_name} failed " f"on {pks_ctx['host']} with error: {err}") return None, None
def process_request(message): from container_service_extension.service import Service LOGGER.debug(f"Incoming request message: {json.dumps(message)}") api_version_header = _parse_accept_header( accept_header=message['headers'].get('Accept')) api_version = _get_api_version_from_accept_header( api_version_header=api_version_header) url_data = _get_url_data(method=message['method'], url=message['requestUri'], api_version=api_version) # noqa: E501 operation = url_data[_OPERATION_KEY] # Check api version and if server is disabled or not # /system operations are excluded from these checks if operation not in (CseOperation.SYSTEM_INFO, CseOperation.SYSTEM_UPDATE): if not Service().is_running(): raise cse_exception.BadRequestError( error_message='CSE service is disabled. ' 'Contact the System Administrator.') else: server_api_version = utils.get_server_api_version() if api_version != server_api_version: raise cse_exception.NotAcceptableRequestError( error_message="Invalid api version specified. Expected " f"api version '{server_api_version}'.") # create request data dict from incoming message data request_data = {} is_cse_3_0_request = _is_cse_3_0_endpoint(message['requestUri']) if len(message['body']) > 0: raw_body = base64.b64decode(message['body']).decode( sys.getfilesystemencoding()) # noqa: E501 request_body = json.loads(raw_body) if is_cse_3_0_request: request_data[shared_constants.RequestKey.V35_SPEC] = request_body else: request_data.update(request_body) LOGGER.debug(f"request body: {request_data}") # update request data dict with query params data if message['queryString']: query_params = dict(parse_qsl(message['queryString'])) if is_cse_3_0_request: request_data[shared_constants.RequestKey.V35_QUERY] = query_params else: request_data.update(query_params) LOGGER.debug(f"query parameters: {query_params}") # update request spec with operation specific data in the url request_data.update(url_data) # remove None values from request payload data = {k: v for k, v in request_data.items() if v is not None} # extract out the authorization token tenant_auth_token = message['headers'].get('x-vcloud-authorization') is_jwt_token = False auth_header = message['headers'].get('Authorization') if auth_header: tokens = auth_header.split(" ") if len(tokens) == 2 and tokens[0].lower() == 'bearer': tenant_auth_token = tokens[1] is_jwt_token = True # create operation context operation_ctx = ctx.OperationContext(tenant_auth_token, is_jwt=is_jwt_token, request_id=message['id']) try: body_content = OPERATION_TO_HANDLER[operation](data, operation_ctx) finally: if not operation_ctx.is_async: operation_ctx.end() if not isinstance(body_content, (list, dict)): body_content = \ {shared_constants.RESPONSE_MESSAGE_KEY: str(body_content)} response = { 'status_code': operation.ideal_response_code, 'body': body_content, } LOGGER.debug(f"Outgoing response: {str(response)}") return response
def on_channel_open(self, channel): LOGGER.debug('Channel opened') self._channel = channel self.add_on_channel_close_callback() self.setup_exchange(self.exchange)
def add_on_connection_close_callback(self): LOGGER.debug('Adding connection close callback') self._connection.add_on_close_callback(self.on_connection_closed)
def close_channel(self): LOGGER.debug('Closing the channel') self._channel.close()
def acknowledge_message(self, delivery_tag): LOGGER.debug('Acknowledging message %s', delivery_tag) self._channel.basic_ack(delivery_tag)
def add_on_cancel_callback(self): LOGGER.debug('Adding consumer cancellation callback') self._channel.add_on_cancel_callback(self.on_consumer_cancelled)
def setup_queue(self, queue_name): LOGGER.debug(f"Declaring queue {queue_name}") self._channel.queue_declare(self.on_queue_declareok, queue_name)
def on_exchange_declareok(self, unused_frame): LOGGER.debug(f"Exchange declared: {unused_frame}") self.setup_queue(self.queue)
def process_request(self, body): LOGGER.debug(f"body: {json.dumps(body)}") reply = {} tokens = body['requestUri'].split('/') cluster_name = None node_name = None spec_request = False config_request = False template_request = False node_request = False cluster_info_request = False node_info_request = False system_request = False ovdc_request = False ovdc_id = None ovdc_info_request = False if len(tokens) > 3: if tokens[3] in ['swagger', 'swagger.json', 'swagger.yaml']: spec_request = True elif tokens[3] == 'template': template_request = True elif tokens[3] == 'system': system_request = True elif tokens[3] == 'ovdc': ovdc_request = True elif tokens[3] != '': cluster_name = tokens[3] if len(tokens) > 4: if cluster_name is not None: if tokens[4] == 'config': config_request = True elif tokens[4] == 'info': cluster_info_request = True elif tokens[4] == 'node': node_request = True elif tokens[4] != '': node_name = tokens[4] elif ovdc_request: ovdc_id = tokens[4] if len(tokens) > 5: if node_name is not None: if tokens[5] == 'info': node_info_request = True elif ovdc_request: if tokens[5] == 'info': ovdc_info_request = True if len(body['body']) > 0: try: request_body = json.loads( base64.b64decode(body['body']).decode( sys.getfilesystemencoding())) except Exception: LOGGER.error(traceback.format_exc()) request_body = {} else: request_body = {} LOGGER.debug(f"request body: {json.dumps(request_body)}") query_params = {} if body['queryString']: query_params = dict(parse_qsl(body['queryString'])) from container_service_extension.service import Service service = Service() if not system_request and not service.is_enabled: raise CseServerError('CSE service is disabled. ' 'Contact the System Administrator.') req_headers = deepcopy(body['headers']) req_query_params = deepcopy(query_params) req_spec = deepcopy(request_body) from container_service_extension.broker_manager import BrokerManager broker_manager = BrokerManager(req_headers, req_query_params, req_spec) from container_service_extension.broker_manager import Operation if body['method'] == 'GET': if ovdc_info_request: req_spec.update({'ovdc_id': ovdc_id}) reply = broker_manager.invoke(Operation.INFO_OVDC) elif ovdc_request: reply = broker_manager.invoke(op=Operation.LIST_OVDCS) elif spec_request: reply = self.get_spec(tokens[3]) elif config_request: req_spec.update({'cluster_name': cluster_name}) reply = broker_manager.invoke(Operation.GET_CLUSTER_CONFIG) elif template_request: result = {} templates = [] server_config = get_server_runtime_config() default_template_name = \ server_config['broker']['default_template'] for t in server_config['broker']['templates']: is_default = t['name'] == default_template_name templates.append({ 'name': t['name'], 'is_default': is_default, 'catalog': server_config['broker']['catalog'], 'catalog_item': t['catalog_item'], 'description': t['description'] }) result['body'] = templates result['status_code'] = 200 reply = result elif cluster_info_request: req_spec.update({'cluster_name': cluster_name}) reply = broker_manager.invoke(Operation.GET_CLUSTER) elif node_info_request: broker = broker_manager.get_broker_based_on_vdc() reply = broker.get_node_info(cluster_name, node_name) elif system_request: result = {} result['body'] = service.info(req_headers) result['status_code'] = OK reply = result elif cluster_name is None: reply = broker_manager.invoke(Operation.LIST_CLUSTERS) elif body['method'] == 'POST': if cluster_name is None: reply = broker_manager.invoke(Operation.CREATE_CLUSTER) else: if node_request: broker = broker_manager.get_broker_based_on_vdc() reply = broker.create_nodes() elif body['method'] == 'PUT': if ovdc_info_request: reply = broker_manager.invoke(Operation.ENABLE_OVDC) elif system_request: reply = service.update_status(req_headers, req_spec) else: req_spec.update({'cluster_name': cluster_name}) reply = broker_manager.invoke(Operation.RESIZE_CLUSTER) elif body['method'] == 'DELETE': if node_request: broker = broker_manager.get_broker_based_on_vdc() reply = broker.delete_nodes() else: req_spec.update({'cluster_name': cluster_name}) reply = broker_manager.invoke(Operation.DELETE_CLUSTER) LOGGER.debug(f"reply: {str(reply)}") return reply
def execute_script_in_nodes(vapp, node_names, script, check_tools=True, wait=True): all_results = [] sys_admin_client = None try: sys_admin_client = vcd_utils.get_sys_admin_client() for node_name in node_names: LOGGER.debug(f"will try to execute script on {node_name}:\n" f"{script}") vs = vs_utils.get_vsphere(sys_admin_client, vapp, vm_name=node_name, logger=LOGGER) vs.connect() moid = vapp.get_vm_moid(node_name) vm = vs.get_vm_by_moid(moid) password = vapp.get_admin_password(node_name) if check_tools: LOGGER.debug(f"waiting for tools on {node_name}") vs.wait_until_tools_ready( vm, sleep=5, callback=_wait_for_tools_ready_callback) _wait_until_ready_to_exec(vs, vm, password) LOGGER.debug(f"about to execute script on {node_name} " f"(vm={vm}), wait={wait}") if wait: result = \ vs.execute_script_in_guest( vm, 'root', password, script, target_file=None, wait_for_completion=True, wait_time=10, get_output=True, delete_script=True, callback=_wait_for_guest_execution_callback) result_stdout = result[1].content.decode() result_stderr = result[2].content.decode() else: result = [ vs.execute_program_in_guest(vm, 'root', password, script, wait_for_completion=False, get_output=False) ] result_stdout = '' result_stderr = '' LOGGER.debug(result[0]) LOGGER.debug(result_stderr) LOGGER.debug(result_stdout) all_results.append(result) finally: if sys_admin_client: sys_admin_client.logout() return all_results
def _wait_for_guest_execution_callback(message, exception=None): LOGGER.debug(message) if exception is not None: LOGGER.error(f"exception: {str(exception)}")
def _wait_for_tools_ready_callback(message, exception=None): LOGGER.debug(f"waiting for guest tools, status: {message}") if exception is not None: LOGGER.error(f"exception: {str(exception)}")
def on_bindok(self, unused_frame): LOGGER.debug('Queue bound') self.start_consuming()
def start_consuming(self): LOGGER.debug('Issuing consumer related RPC commands') self.add_on_cancel_callback() self._consumer_tag = self._channel.basic_consume( self.on_message, self.queue)
def on_queue_declareok(self, method_frame): LOGGER.debug(f"Binding {self.exchange} to {self.queue} with " f"{self.routing_key}") self._channel.queue_bind(self.on_bindok, self.queue, self.exchange, self.routing_key)
def on_consumer_cancelled(self, method_frame): LOGGER.debug('Consumer was cancelled remotely, shutting down: %r', method_frame) if self._channel: self._channel.close()
def _process_template_compute_policy_compliance(self, msg_update_callback=None): msg = "Processing compute policy for k8s templates." LOGGER.info(msg) if msg_update_callback: msg_update_callback.general_no_color(msg) log_filename = None log_wire = str_to_bool(self.config['service'].get('log_wire')) if log_wire: log_filename = SERVER_DEBUG_WIRELOG_FILEPATH org_name = self.config['broker']['org'] catalog_name = self.config['broker']['catalog'] api_version = self.config['vcd']['api_version'] client = None try: if float(api_version) >= float( ApiVersion.VERSION_32.value): # noqa: E501 # TODO this api version 32 client should be removed once # vcd can handle cp removal/replacement on version 33 client = Client(self.config['vcd']['host'], api_version=ApiVersion.VERSION_32.value, verify_ssl_certs=self.config['vcd']['verify'], log_file=log_filename, log_requests=log_wire, log_headers=log_wire, log_bodies=log_wire) else: client = Client(self.config['vcd']['host'], api_version=api_version, verify_ssl_certs=self.config['vcd']['verify'], log_file=log_filename, log_requests=log_wire, log_headers=log_wire, log_bodies=log_wire) credentials = BasicLoginCredentials(self.config['vcd']['username'], SYSTEM_ORG_NAME, self.config['vcd']['password']) client.set_credentials(credentials) cpm = ComputePolicyManager(client) try: for template in self.config['broker']['templates']: policy_name = template[LocalTemplateKey.COMPUTE_POLICY] catalog_item_name = template[ LocalTemplateKey.CATALOG_ITEM_NAME] # noqa: E501 # if policy name is not empty, stamp it on the template if policy_name: policy = cpm.get_policy(policy_name=policy_name) # create the policy if not present in system if not policy: msg = "Creating missing compute policy " \ f"'{policy_name}'." if msg_update_callback: msg_update_callback.info(msg) LOGGER.debug(msg) policy = cpm.add_policy(policy_name=policy_name) msg = f"Assigning compute policy '{policy_name}' to " \ f"template '{catalog_item_name}'." if msg_update_callback: msg_update_callback.general(msg) LOGGER.debug(msg) cpm.assign_compute_policy_to_vapp_template_vms( compute_policy_href=policy['href'], org_name=org_name, catalog_name=catalog_name, catalog_item_name=catalog_item_name) else: # empty policy name means we should remove policy from # template msg = f"Removing compute policy from template " \ f"'{catalog_item_name}'." if msg_update_callback: msg_update_callback.general(msg) LOGGER.debug(msg) cpm.remove_all_compute_policies_from_vapp_template_vms( org_name=org_name, catalog_name=catalog_name, catalog_item_name=catalog_item_name) except OperationNotSupportedException: msg = "Compute policy not supported by vCD. Skipping " \ "assigning/removing it to/from templates." if msg_update_callback: msg_update_callback.info(msg) LOGGER.debug(msg) finally: if client: client.logout()
def on_cancelok(self, unused_frame): LOGGER.debug('RabbitMQ acknowledged the cancellation' 'of the consumer') self.close_channel()
def create_nodes_thread(self): LOGGER.debug(f"About to add nodes to cluster with name: " f"{self.cluster_name}") try: server_config = get_server_runtime_config() org_resource = self.tenant_client.get_org() org = Org(self.tenant_client, resource=org_resource) vdc = VDC(self.tenant_client, href=self.cluster['vdc_href']) vapp = VApp(self.tenant_client, href=self.cluster['vapp_href']) template = self._get_template() self._update_task( TaskStatus.RUNNING, message=f"Creating {self.req_spec.get(RequestKey.NUM_WORKERS)}" f" node(s) for {self.cluster_name}({self.cluster_id})") node_type = NodeType.WORKER if self.req_spec.get(RequestKey.ENABLE_NFS): node_type = NodeType.NFS new_nodes = add_nodes(self.req_spec.get(RequestKey.NUM_WORKERS), template, node_type, server_config, self.tenant_client, org, vdc, vapp, self.req_spec) if node_type == NodeType.NFS: self._update_task( TaskStatus.SUCCESS, message=f"Created " f"{self.req_spec.get(RequestKey.NUM_WORKERS)} " f"node(s) for " f"{self.cluster_name}({self.cluster_id})") elif node_type == NodeType.WORKER: self._update_task( TaskStatus.RUNNING, message=f"Adding " f"{self.req_spec.get(RequestKey.NUM_WORKERS)} " f"node(s) to cluster " f"{self.cluster_name}({self.cluster_id})") target_nodes = [] for spec in new_nodes['specs']: target_nodes.append(spec['target_vm_name']) vapp.reload() join_cluster(server_config, vapp, template, target_nodes) self._update_task( TaskStatus.SUCCESS, message=f"Added " f"{self.req_spec.get(RequestKey.NUM_WORKERS)} " f"node(s) to cluster " f"{self.cluster_name}({self.cluster_id})") except NodeCreationError as e: error_obj = error_to_json(e) LOGGER.error(traceback.format_exc()) stack_trace = \ ''.join(error_obj[ERROR_MESSAGE_KEY][ERROR_STACKTRACE_KEY]) self._update_task( TaskStatus.ERROR, error_message=error_obj[ERROR_MESSAGE_KEY][ERROR_DESCRIPTION_KEY], # noqa: E501 stack_trace=stack_trace) raise except Exception as e: error_obj = error_to_json(e) LOGGER.error(traceback.format_exc()) stack_trace = \ ''.join(error_obj[ERROR_MESSAGE_KEY][ERROR_STACKTRACE_KEY]) self._update_task( TaskStatus.ERROR, error_message=error_obj[ERROR_MESSAGE_KEY][ERROR_DESCRIPTION_KEY], # noqa: E501 stack_trace=stack_trace) finally: self._disconnect_sys_admin()
def on_connection_open(self, unused_connection): LOGGER.debug('Connection opened') self.add_on_connection_close_callback() self.open_channel()
def add_on_channel_close_callback(self): LOGGER.debug('Adding channel close callback') self._channel.add_on_close_callback(self.on_channel_closed)
def open_channel(self): LOGGER.debug('Creating a new channel') self._connection.channel(on_open_callback=self.on_channel_open)
def on_exchange_declareok(self, unused_frame): LOGGER.debug('Exchange declared: %s' % unused_frame) self.setup_queue(self.queue)
def process_request(self, body): LOGGER.debug('body: %s' % json.dumps(body)) reply = {} tokens = body['requestUri'].split('/') cluster_name = None node_name = None spec_request = False config_request = False template_request = False node_request = False cluster_info_request = False node_info_request = False system_request = False ovdc_request = False ovdc_id = None ovdc_info_request = False if len(tokens) > 3: if tokens[3] in ['swagger', 'swagger.json', 'swagger.yaml']: spec_request = True elif tokens[3] == 'template': template_request = True elif tokens[3] == 'system': system_request = True elif tokens[3] == 'ovdc': ovdc_request = True elif tokens[3] != '': cluster_name = tokens[3] if len(tokens) > 4: if cluster_name is not None: if tokens[4] == 'config': config_request = True elif tokens[4] == 'info': cluster_info_request = True elif tokens[4] == 'node': node_request = True elif tokens[4] != '': node_name = tokens[4] elif ovdc_request: ovdc_id = tokens[4] if len(tokens) > 5: if node_name is not None: if tokens[5] == 'info': node_info_request = True elif ovdc_request: if tokens[5] == 'info': ovdc_info_request = True if len(body['body']) > 0: try: request_body = json.loads( base64.b64decode(body['body']).decode( sys.getfilesystemencoding())) except Exception: LOGGER.error(traceback.format_exc()) request_body = None else: request_body = None LOGGER.debug('request body: %s' % json.dumps(request_body)) from container_service_extension.service import Service service = Service() if not system_request and not service.is_enabled: raise CseServerError('CSE service is disabled. ' 'Contact the System Administrator.') if body['method'] == 'GET': if ovdc_info_request: on_the_fly_request_body = {'ovdc_id': ovdc_id} broker = get_new_broker(body['headers'], on_the_fly_request_body) reply = broker.ovdc_info_for_kubernetes() elif spec_request: reply = self.get_spec(tokens[3]) elif config_request: broker = get_new_broker(body['headers'], request_body) reply = broker.get_cluster_config(cluster_name) elif template_request: result = {} templates = [] server_config = get_server_runtime_config() default_template_name = \ server_config['broker']['default_template'] for t in server_config['broker']['templates']: is_default = t['name'] == default_template_name templates.append({ 'name': t['name'], 'is_default': is_default, 'catalog': server_config['broker']['catalog'], 'catalog_item': t['catalog_item'], 'description': t['description'] }) result['body'] = templates result['status_code'] = 200 reply = result elif cluster_info_request: broker = get_new_broker(body['headers'], request_body) reply = broker.get_cluster_info(cluster_name) elif node_info_request: broker = get_new_broker(body['headers'], request_body) reply = broker.get_node_info(cluster_name, node_name) elif system_request: result = {} result['body'] = service.info(body['headers']) result['status_code'] = OK reply = result elif cluster_name is None: broker = get_new_broker(body['headers'], request_body) reply = broker.list_clusters() elif body['method'] == 'POST': if cluster_name is None: broker = get_new_broker(body['headers'], request_body) reply = broker.create_cluster() else: if node_request: broker = get_new_broker(body['headers'], request_body) reply = broker.create_nodes() elif body['method'] == 'PUT': if ovdc_info_request: broker = get_new_broker(body['headers'], request_body) reply = broker.enable_ovdc_for_kubernetes() elif system_request: reply = service.update_status(body['headers'], request_body) elif body['method'] == 'DELETE': if node_request: broker = get_new_broker(body['headers'], request_body) reply = broker.delete_nodes() else: on_the_fly_request_body = {'name': cluster_name} broker = get_new_broker(body['headers'], on_the_fly_request_body) reply = broker.delete_cluster() LOGGER.debug('reply: %s' % str(reply)) return reply
def setup_queue(self, queue_name): LOGGER.debug('Declaring queue %s', queue_name) self._channel.queue_declare(self.on_queue_declareok, queue_name)
def process_request(body): from container_service_extension.service import Service LOGGER.debug(f"Incoming request body: {json.dumps(body)}") url_data = _get_url_data(body['method'], body['requestUri']) operation = url_data[_OPERATION_KEY] # check if server is disabled if operation not in (CseOperation.SYSTEM_INFO, CseOperation.SYSTEM_UPDATE)\ and not Service().is_running(): raise e.BadRequestError(error_message='CSE service is disabled. ' 'Contact the System Administrator.') # create request data dict from request body data request_data = {} request_body = None if len(body['body']) > 0: raw_body = base64.b64decode(body['body']).decode( sys.getfilesystemencoding()) # noqa: E501 request_body = json.loads(raw_body) request_data.update(request_body) LOGGER.debug(f"request body: {request_data}") # update request data dict with query params data query_params = None if body['queryString']: query_params = dict(parse_qsl(body['queryString'])) request_data.update(query_params) LOGGER.debug(f"query parameters: {query_params}") # update request spec with operation specific data in the url request_data.update(url_data) # remove None values from request payload data = {k: v for k, v in request_data.items() if v is not None} # extract out the authorization token tenant_auth_token = body['headers'].get('x-vcloud-authorization') is_jwt_token = False auth_header = body['headers'].get('Authorization') if auth_header: tokens = auth_header.split(" ") if len(tokens) == 2 and tokens[0].lower() == 'bearer': tenant_auth_token = tokens[1] is_jwt_token = True # process the request context = ctx.RequestContext(tenant_auth_token, is_jwt=is_jwt_token, request_body=request_body, request_url_data=url_data, request_query_params=query_params, request_id=body['id']) is_def_request = def_utils.is_def_supported_by_cse_server( ) and _is_def_endpoint(body['requestUri']) # noqa: E501 try: if is_def_request: body_content = def_handler.OPERATION_TO_METHOD[operation]( context) # noqa: E501 else: body_content = OPERATION_TO_HANDLER[operation](data, context) finally: if not context.is_async: context.end() if not isinstance(body_content, (list, dict)): body_content = {RESPONSE_MESSAGE_KEY: str(body_content)} response = { 'status_code': operation.ideal_response_code, 'body': body_content, } LOGGER.debug(f"Outgoing response: {str(response)}") return response
def on_queue_declareok(self, method_frame): LOGGER.debug('Binding %s to %s with %s', self.exchange, self.queue, self.routing_key) self._channel.queue_bind(self.on_bindok, self.queue, self.exchange, self.routing_key)