Merge remote-tracking branch 'origin/staging' into OCF44-helm-refactor

import connexion

import logging

from api_invoker_management import encoder

from flask import Flask, jsonify, request

import encoder

from flask_jwt_extended import JWTManager, jwt_required, create_access_token

from pymongo import MongoClient

from .config import Config

from .core.consumer_messager import Subscriber

from config import Config

from core.consumer_messager import Subscriber

from logging.handlers import RotatingFileHandler

import os

from fluent import sender

from opentelemetry.instrumentation.redis import RedisInstrumentor

import sys

import uuid

NAME = "Invoker-Service"

def configure_monitoring(app, config):

jwt = JWTManager(app.app)

configure_logging(app.app)

if eval(os.environ.get("MONITORING").lower().capitalize()):

monitoring_value = os.environ.get("MONITORING", "").lower()

if monitoring_value == "true":

    configure_monitoring(app.app, config.get_config())

executor = Executor(app.app)

@app.app.before_first_request

def create_listener_message():

    executor.submit(subscriber.listen)

 No newline at end of file

if __name__ == '__main__':

    import logging

    app.run(debug=True, port=8080)

class Config:

	def __init__(self):

		self.cached = 0

		self.file="./config.yaml"

		self.file="../config.yaml"

		self.my_config = {}

		stamp = os.stat(self.file).st_mtime

import connexion

from api_invoker_management.models.api_invoker_enrolment_details import APIInvokerEnrolmentDetails  # noqa: E501

from ..models.api_invoker_enrolment_details import APIInvokerEnrolmentDetails  # noqa: E501

from ..core.apiinvokerenrolmentdetails import InvokerManagementOperations

from ..core.validate_user import ControlAccess

import json

from flask import Response, request, current_app

from flask_jwt_extended import jwt_required, get_jwt_identity

from ..encoder import JSONEncoder

from ..models.problem_details import ProblemDetails

from cryptography import x509

from cryptography.hazmat.backends import default_backend

from ..core.publisher import Publisher

from functools import wraps

invoker_operations = InvokerManagementOperations()

from flask import current_app, Flask, Response

import json

from datetime import datetime

from ..util import dict_to_camel_case

from ..util import dict_to_camel_case, clean_empty, serialize_clean_camel_case

from .auth_manager import AuthManager

from .resources import Resource

from ..config import Config

        if old_values is None:

            current_app.logger.error("Not found api invoker id")

            return not_found_error(detail="Please provide an existing Netapp ID", cause= "Not exist NetappID" )

            return not_found_error(detail="Please provide an existing Network App ID", cause= "Not exist Network App ID" )

        return old_values

            'common_name': invoker_id

        }

        response = requests.request("POST", url, headers=headers, data=data, verify = False)

        response = requests.request("POST", url, headers=headers, data=data, verify = self.config["ca_factory"].get("verify", False))

        print(response)

        response_payload = json.loads(response.text)

        api_invoker_id = 'INV'+str(secrets.token_hex(15))

        cert = self.__sign_cert(apiinvokerenrolmentdetail.onboarding_information.api_invoker_public_key, api_invoker_id)

        apiinvokerenrolmentdetail.api_invoker_id = api_invoker_id

        current_app.logger.debug(cert)

        apiinvokerenrolmentdetail.onboarding_information.api_invoker_certificate = cert['data']['certificate']

        self.auth_manager.add_auth_invoker(cert['data']['certificate'], api_invoker_id)

        res = make_response(object=apiinvokerenrolmentdetail, status=201)

        res = make_response(object=serialize_clean_camel_case(apiinvokerenrolmentdetail), status=201)

        res.headers['Location'] = "/api-invoker-management/v1/onboardedInvokers/" + str(api_invoker_id)

        if res.status_code == 201:

            RedisEvent("API_INVOKER_ONBOARDED", "apiInvokerIds", [str(api_invoker_id)]).send_event()

        return res

        # except Exception as e:

        #     exception = "An exception occurred in create invoker"

        #     current_app.logger.error(exception + "::" + str(e))

        #     return internal_server_error(detail=exception, cause=str(e))

    def update_apiinvokerenrolmentdetail(self, onboard_id, apiinvokerenrolmentdetail):

        mycol = self.db.get_col_by_name(self.db.invoker_enrolment_details)

            current_app.logger.debug("Invoker Resource inserted in database")

            res = make_response(object=APIInvokerEnrolmentDetails().from_dict(dict_to_camel_case(result)), status=200)

            invoker_updated = APIInvokerEnrolmentDetails().from_dict(dict_to_camel_case(result))

            res = make_response(object=serialize_clean_camel_case(invoker_updated), status=200)

            if res.status_code == 200:

                current_app.logger.info("Invoker Updated")

                RedisEvent("API_INVOKER_UPDATED", "apiInvokerIds", [onboard_id]).send_event()

            current_app.logger.debug("Invoker resource removed from database")

            current_app.logger.debug("Netapp offboarded sucessfuly")

            out =  "The Netapp matching onboardingId  " + onboard_id + " was offboarded."

            out =  "The Network App matching onboardingId  " + onboard_id + " was offboarded."

            res = make_response(out, status=204)

            if res.status_code == 204:

                current_app.logger.info("Invoker Removed")

from flask import current_app

from cryptography import x509

from cryptography.hazmat.backends import default_backend

from .resources import Resource