oci-cli 3.64.1__py3-none-any.whl → 3.65.1__py3-none-any.whl

services/service_mesh/src/oci_cli_service_mesh/service_mesh_cli_extended.py

@@ -1,57 +0,0 @@
-# coding: utf-8
-# Copyright (c) 2016, 2021, Oracle and/or its affiliates.  All rights reserved.
-# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
-import os.path
-import sys
-
-import click
-from oci_cli import cli_util
-from oci_cli.aliasing import CommandGroupWithAlias
-
-from services.service_mesh.src.oci_cli_service_mesh.generated import servicemesh_cli
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.bundle_analyser import BundleAnalyser
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.report_orchestrator \
-    import ReportOrchestrator
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.bundle_helper import BundleHelper
-
-
-@click.command(cli_util.override('service_mesh.debug_group.command_name', 'debug'), cls=CommandGroupWithAlias,
-               help="""Debug enables customers to troubleshoot service-mesh resources.""")
-@cli_util.help_option_group
-def debug_group():
-    pass
-
-
-# oci service-mesh debug
-servicemesh_cli.service_mesh_root_group.add_command(debug_group)
-
-
-# oci service-mesh debug report
-# oci service-mesh debug report --resource-id <ocid>
-# oci service-mesh debug report --resource-id <ocid> --k8s-context <path_to_config_file>
-@debug_group.command(name=cli_util.override('service_mesh.report.command_name', 'report'),
-                     help=u"""Generates report to troubleshoot Service Mesh resources and setup.""")
-@cli_util.option('--resource-id', required=False, help=u"""The [OCID] of the service-mesh resource.""")
-@cli_util.option('--kubeconfig', required=False, help=u"""The filepath of the config file containing the kubernetes config of the Kubernetes Cluster. If not specified default config file will be applied.""")
-@cli_util.option('--context', required=False, help=u"""Context to be used in the kube config file. If not specified, the current-context is used by default.""")
-@cli_util.option('--thread-pool-size', required=False, type=click.IntRange(1, 50), help=u"""The Size of thread pool to execute the command""")
-@cli_util.help_option
-@click.pass_context
-@cli_util.wrap_exceptions
-def generate_mesh(ctx, resource_id, kubeconfig, context, thread_pool_size):
-    try:
-        report_orchestrator = ReportOrchestrator(resource_id, kubeconfig, context, thread_pool_size)
-        result = report_orchestrator.build_report()
-        if result is not None:
-            click.echo(result, file=sys.stderr)
-        else:
-            click.echo('Report generation successful.', file=sys.stdout)
-            bundle_file_path = os.path.join(BundleHelper.get_home_directory(), BundleHelper.get_bundle_name())
-            # click.echo - Bundle file path
-            click.echo('\nBundle file path: {}'.format(bundle_file_path))
-            # call Analyser
-            bundle_analyzer = BundleAnalyser(bundle_file_path=bundle_file_path)
-            analyze = bundle_analyzer.analyze()
-    except Exception as e:
-        click.echo('Report generation unsuccessful. Some problem occurred during report generation. {}'.format(e),
-                   file=sys.stderr)

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/__init__.py

@@ -1,76 +0,0 @@
-# coding: utf-8
-# Copyright (c) 2016, 2022, Oracle and/or its affiliates.  All rights reserved.
-# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.aggregators.aggregation_orchestrator import \
-    AggregationOrchestrator, ReportData
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.event import Event, EventType, \
-    OperationType
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.task_orchestrator import TaskOrchestrator
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.task_request import TaskRequestType, \
-    TaskConfiguration, MeshReportTaskRequest, ResourceTaskRequest, PodTaskRequest, TaskRequest, VdbTaskRequest, \
-    IgdTaskRequest, NamespacesTaskRequest, FileTaskRequest, MeshResourcesTaskRequest, CommonTaskRequest, CsvTaskRequest, \
-    ValidateCrdsTaskRequest, WebhooksTaskRequest
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.webhooks_worker import WebhooksTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.kubectl_command_helper import \
-    KubeCommandHelper
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.summary import BasicPodSummary, \
-    MeshData, PodSummary, CustomResourceSummary, MeshResources
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.common_worker import CommonTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.csv_worker import CsvTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.file_worker import FileTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.igd_worker import IgdTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.mesh_report_worker import \
-    MeshReportTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.mesh_resources_worker import \
-    MeshResourcesTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.namespaces_worker import \
-    NamespacesTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.pod_worker import PodTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.resource_worker import \
-    ResourceTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.task_worker import MeshTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.vdb_worker import VdbTask
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.validate_crds_worker import ValidateCrdsTask
-
-__all__ = ["AggregationOrchestrator",
-           "ReportData",
-           "KubeCommandHelper",
-           "BasicPodSummary",
-           "MeshData",
-           "PodSummary",
-           "CustomResourceSummary",
-           "MeshResources",
-           "CommonTask",
-           "CsvTask",
-           "FileTask",
-           "IgdTask",
-           "MeshReportTask",
-           "MeshResourcesTask",
-           "NamespacesTask",
-           "PodTask",
-           "ResourceTask",
-           "MeshTask",
-           "VdbTask",
-           "Event",
-           "OperationType",
-           "EventType",
-           "TaskOrchestrator",
-           "TaskRequestType",
-           "TaskConfiguration",
-           "TaskRequest",
-           "PodTaskRequest",
-           "ResourceTaskRequest",
-           "MeshReportTaskRequest",
-           "VdbTaskRequest",
-           "IgdTaskRequest",
-           "NamespacesTaskRequest",
-           "FileTaskRequest",
-           "CsvTaskRequest",
-           "MeshResourcesTaskRequest",
-           "CommonTaskRequest",
-           "WebhooksTask",
-           "WebhooksTaskRequest",
-           "ValidateCrdsTask",
-           "ValidateCrdsTaskRequest",
-           "BundleAnalyser"
-           ]

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/aggregators/__init__.py

@@ -1,3 +0,0 @@
-# coding: utf-8
-# Copyright (c) 2016, 2022, Oracle and/or its affiliates.  All rights reserved.
-# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/aggregators/aggregation_orchestrator.py

@@ -1,88 +0,0 @@
-# coding: utf-8
-# Copyright (c) 2016, 2022, Oracle and/or its affiliates.  All rights reserved.
-# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
-import json
-import queue
-
-import click
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.bundle_helper import \
-    save_as_json
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.event import OperationType
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.constants import MESH_PLURAL, \
-    VS_PLURAL, VD_PLURAL, IG_PLURAL
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.summary import MeshData
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.helper import \
-    get_resource_type_from_ocid
-
-
-class ReportData:
-    def __init__(self, parent: str = None):
-        self.data = dict()
-        self.parent = parent
-
-    def to_json(self):
-        return json.dumps(self, default=lambda o: o.__dict__, allow_nan=False)
-
-
-class AggregationOrchestrator():
-
-    def __init__(self, ocid):
-        # This object will be serialized to Json. Do not add non json serializable data
-        self.reports_dict = {}
-        self.ocid = ocid
-
-    def aggregate_events(self, events: queue.Queue):
-        try:
-            while not events.empty():
-                event = events.get()
-                for dest in event.store:
-                    if dest not in self.reports_dict.keys():
-                        self.reports_dict[dest] = ReportData(event.identifications.get(dest))
-                    dest_value = self.reports_dict[dest]
-                    for operation in event.operations:
-                        event_type = event.event_type.value.lower()
-                        if operation == OperationType.ACCUMULATE:
-                            if event_type + "_count" not in dest_value.data.keys():
-                                dest_value.data[event_type + "_count"] = 0
-                            dest_value.data[event_type + "_count"] += 1
-                        elif operation == OperationType.STORE_MULTI_EVENT:
-                            if event_type not in dest_value.data.keys():
-                                dest_value.data[event_type] = []
-                            event_list = dest_value.data[event_type]
-                            event_list.append(event.data)
-                        elif operation == OperationType.STORE_SINGLE_EVENT:
-                            dest_value.data[event_type] = event.data
-
-        except Exception as error:
-            click.echo('AggregationOrchestrator Exception: {}'.format(error))
-
-        if self.ocid is None:
-            for ocid, report in self.reports_dict.items():
-                save_as_json(ocid, None, report.data)
-        else:
-            # Save the aggregated reports
-            resource_type = get_resource_type_from_ocid(self.ocid)
-            for ocid, report in self.reports_dict.items():
-                current_resource_type = get_resource_type_from_ocid(ocid)
-                if current_resource_type != resource_type:
-                    continue
-                relative_path = None
-                if current_resource_type == MESH_PLURAL:
-                    # generate mesh report
-                    mesh_data = MeshData(mesh_id=ocid)
-                    relative_path = mesh_data.get_mesh_hierarchy()
-                elif current_resource_type == VS_PLURAL:
-                    # generate vs report
-                    mesh_data = MeshData(mesh_id=report.parent, vs_id=ocid)
-                    relative_path = mesh_data.get_virtual_service_hierarchy()
-                elif current_resource_type == VD_PLURAL:
-                    # generate vd report
-                    mesh_data = MeshData(mesh_id=self.reports_dict[report.parent].parent, vs_id=report.parent, vd_id=ocid)
-                    relative_path = mesh_data.get_virtual_deployment_hierarchy()
-                elif current_resource_type == IG_PLURAL:
-                    # generate ig report
-                    mesh_data = MeshData(mesh_id=report.parent, ig_id=ocid)
-                    relative_path = mesh_data.get_ingress_gateway_hierarchy()
-
-                if relative_path is not None:
-                    save_as_json(ocid, relative_path, report.data)

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/bundle_analyser.py

@@ -1,163 +0,0 @@
-# coding: utf-8
-# Copyright (c) 2016, 2022, Oracle and/or its affiliates.  All rights reserved.
-# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
-import zipfile
-import json
-import re
-import sys
-import click
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.constants import ITEMS, STATUS, \
-    PHASE, VALID_CRDS_LIST, WEBHOOKS_LIST, IssueType, TROUBLESHOOT_DICT, OPERATOR_SERVICES_LIST, REPORT, CSV, PENDING, \
-    SUCCEEDED, PROXY_VERSION, DYNAMIC_VERSION, OLM_VERSION
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.event import EventType
-
-'''
-Parse the report and bundle to analyze and provide required help to troubleshoot issues in mesh setup.
-'''
-
-
-class BundleAnalyser:
-
-    def __init__(self, bundle_file_path, sdk_client=None):
-        self.bundle_file_path = bundle_file_path + ".zip"
-        self.sdk_client = sdk_client
-        self.csv_json_contents = None
-        self.report_json_contents = None
-        self.report_json = None
-        self.csv_json = None
-
-    def load_contents(self):
-        # load contents of report and csv file for analyzing
-        bundle = zipfile.ZipFile(self.bundle_file_path, 'r')
-        for filename in bundle.namelist():
-            if re.search(CSV, filename):
-                self.csv_json = bundle.open(filename, 'r')
-                self.csv_json_contents = json.loads(self.csv_json.read())
-            if re.search(REPORT, filename):
-                self.report_json = bundle.open(filename, 'r')
-                self.report_json_contents = json.loads(self.report_json.read())
-
-    # OLM should be version in constant
-    def validate_olm_version(self):
-        OLM = EventType.OLM.value.lower()
-        if OLM in self.report_json_contents:
-            olm = self.report_json_contents[OLM]
-            if olm is not None:
-                olm_version = olm["version"]
-                if olm_version == OLM_VERSION:
-                    click.echo('\nOLM version: {}'.format(olm_version), file=sys.stdout)
-                else:
-                    click.echo(IssueType.INCOMPATIBLE_OLM_VERSION.describe())
-                    click.echo("Refer - " + TROUBLESHOOT_DICT[IssueType.INCOMPATIBLE_OLM_VERSION])
-
-    def validate_csv_status(self):
-        if self.csv_json_contents is not None and ITEMS in self.csv_json_contents and len(
-                self.csv_json_contents[ITEMS]) > 0:
-            csv = self.csv_json_contents[ITEMS][0]
-            if STATUS in csv and PHASE in csv[STATUS]:
-                csv_status = csv[STATUS][PHASE]
-                if csv_status == PENDING:
-                    click.echo(IssueType.CSV_STATUS_NOT_SUCCEEDED.describe())
-                    click.echo(TROUBLESHOOT_DICT[IssueType.CSV_STATUS_NOT_SUCCEEDED])
-                elif csv_status == SUCCEEDED:
-                    click.echo('\nCSV status: {}'.format(csv_status), file=sys.stdout)
-
-    def config_version_summary(self):
-        POD_SUMMARY = EventType.POD_SUMMARY.value.lower()
-        if POD_SUMMARY in self.report_json_contents:
-            pods_summary = self.report_json_contents[POD_SUMMARY]
-
-            config_version_stats = {}
-            if pods_summary is not None:
-                for pod_summary in pods_summary:
-                    config_version_stats.setdefault(pod_summary[DYNAMIC_VERSION], 0)
-                    config_version_stats[pod_summary[DYNAMIC_VERSION]] += 1
-                click.echo("\n|{:^20}|".format("Config Versions"))
-                click.echo("|{:^10} | {:^10}|".format("Version", "Count"))
-                for version, count in config_version_stats.items():
-                    click.echo("|{:^10} | {:^10}|".format(version, str(count)))
-                    if len(config_version_stats) > 1:
-                        click.echo(IssueType.INCOMPATIBLE_VERSIONS.describe())
-                        click.echo(TROUBLESHOOT_DICT[IssueType.INCOMPATIBLE_VERSIONS])
-                    elif len(config_version_stats) == 1:
-                        click.echo("All  configs are of the same version")
-
-    def validate_proxy_and_sidecar_version(self):
-        POD_SUMMARY = EventType.POD_SUMMARY.value.lower()
-        if POD_SUMMARY in self.report_json_contents:
-            pods_summary = self.report_json_contents[POD_SUMMARY]
-            version_stats = {}
-            if pods_summary is not None:
-                for pod_summary in pods_summary:
-                    version_stats.setdefault(pod_summary[PROXY_VERSION], 0)
-                    version_stats[pod_summary[PROXY_VERSION]] += 1
-
-                click.echo("\n|{:^30}|".format("Sidecar Image Versions"))
-                click.echo("|{:^15} | {:^15}|".format("Version", "Count"))
-
-                for version, count in version_stats.items():
-                    click.echo("|{:^15} | {:^15}|".format(version, str(count)))
-                if len(version_stats) > 1:
-                    click.echo(IssueType.MULTIPLE_SIDECAR_VERSIONS.describe())
-                    click.echo(TROUBLESHOOT_DICT[IssueType.MULTIPLE_SIDECAR_VERSIONS])
-                elif len(version_stats) == 1:
-                    click.echo("All sidecars are using same version")
-
-    def operator_services(self):
-        OPERATOR_SERVICES = EventType.OPERATOR_SERVICES.value.lower()
-        if OPERATOR_SERVICES in self.report_json_contents:
-            services_list = self.report_json_contents[OPERATOR_SERVICES]
-            missing_services = list(set(services_list) ^ set(OPERATOR_SERVICES_LIST))
-            if len(missing_services) > 0:
-                click.echo(IssueType.MISSING_OPERATOR_SERVICES.describe())
-                click.echo('\nServices not found: {}'.format(missing_services), file=sys.stdout)
-                click.echo(TROUBLESHOOT_DICT[IssueType.MISSING_OPERATOR_SERVICES])
-            else:
-                click.echo('\nAll Operator Services are installed')
-
-    def validate_crds(self):
-        SERVICE_MESH_CRDS = EventType.SERVICE_MESH_CRDS.value.lower()
-        if SERVICE_MESH_CRDS in self.report_json_contents:
-            crds_list = self.report_json_contents[SERVICE_MESH_CRDS]
-            missing_crds = list(set(crds_list) ^ set(VALID_CRDS_LIST))
-            if len(missing_crds) > 0:
-                click.echo(IssueType.MISSING_MESH_CRDS.describe())
-                click.echo('\nCRDs not found: {}'.format(missing_crds), file=sys.stdout)
-                click.echo(TROUBLESHOOT_DICT[IssueType.MISSING_MESH_CRDS])
-            else:
-                click.echo('\nAll Mesh Custom Resources are installed')
-
-    def validate_webhooks(self):
-        SERVICE_MESH_WEBHOOKS = EventType.SERVICE_MESH_WEBHOOKS.value.lower()
-        if SERVICE_MESH_WEBHOOKS in self.report_json_contents:
-            webhooks_list = self.report_json_contents[SERVICE_MESH_WEBHOOKS]
-            missing_webhooks = list(set(webhooks_list) ^ set(WEBHOOKS_LIST))
-            if len(missing_webhooks) > 0:
-                click.echo(IssueType.MISSING_MESH_WEBHOOKS.describe())
-                click.echo('\nWebhooks not found: {}'.format(missing_webhooks), file=sys.stdout)
-                click.echo(TROUBLESHOOT_DICT[IssueType.MISSING_MESH_WEBHOOKS])
-
-            else:
-                click.echo('\nAll Mesh Webhooks are installed')
-
-    def analyze(self):
-        # load contents of report and csv file for analyzing
-        self.load_contents()
-        # Parse the report and echo suggestions
-        click.echo("=============================== Mesh Report Analysis ===============================")
-        # Go through the array of report pod summary and provide stats
-
-        # Validate if pod summary is present
-        if self.report_json_contents is not None:
-            # validate_proxy_version()
-            self.validate_olm_version()
-            self.validate_proxy_and_sidecar_version()
-            # validate dynamic and static config version
-            self.config_version_summary()
-            # Validate if Operator Services are present
-            self.operator_services()
-            # Validate if all the webhooks and CRDs are present
-            self.validate_webhooks()
-            self.validate_crds()
-
-        return None

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/event.py

@@ -1,43 +0,0 @@
-# coding: utf-8
-# Copyright (c) 2016, 2022, Oracle and/or its affiliates.  All rights reserved.
-# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
-from enum import Enum
-from typing import Set, Dict
-
-
-class EventType(Enum):
-    OCI_CLI_VERSION = 'OCI_CLI_VERSION'
-    CSV_STATUS = 'CSV_STATUS'
-    INSTALL_PLAN_STATUS = 'INSTALL_PLAN_STATUS'
-    OSOK = 'OCI_SERVICE_OPERATOR_FOR_KUBERNETES'
-    OLM = 'OLM'
-    METRICS_SERVER = 'METRICS_SERVER'
-    SIDECAR_INJECTION_ENABLED_NAMESPACES = 'SIDECAR_INJECTION_ENABLED_NAMESPACES'
-    POD_SUMMARY = 'POD_SUMMARY'
-    CATALOG_OPERATOR = 'CATALOG_OPERATOR'  # catalog operator
-    SERVICE_MESH_CRDS = 'SERVICE_MESH_CRDS'
-    SERVICE_MESH_WEBHOOKS = 'SERVICE_MESH_WEBHOOKS'
-    PROMETHEUS_VERSION = 'PROMETHEUS_VERSION'
-    GRAFANA_VERSION = 'GRAFANA_VERSION'
-    OPERATOR_SERVICES = 'OPERATOR_SERVICES'
-
-
-class OperationType(Enum):
-    ACCUMULATE = 'ACCUMULATE'
-    STORE_SINGLE_EVENT = 'STORE_SINGLE_EVENT'
-    STORE_MULTI_EVENT = 'STORE_MULTI_EVENT'
-
-
-# Identifications are set of string to Apply operation, meshId, virtualServiceId .. etc.
-class Event:
-    def __init__(self,
-                 event_type: EventType,
-                 operations: Set[OperationType],
-                 data: Dict,
-                 identifications: Dict,
-                 store: Set[str]):
-        self.event_type = event_type
-        self.operations = operations
-        self.data = data
-        self.identifications = identifications
-        self.store = store

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/handlers/__init__.py

@@ -1,3 +0,0 @@
-# coding: utf-8
-# Copyright (c) 2016, 2021, Oracle and/or its affiliates.  All rights reserved.
-# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/handlers/debug_handler.py

@@ -1,209 +0,0 @@
-# coding: utf-8
-# Copyright (c) 2016, 2021, Oracle and/or its affiliates.  All rights reserved.
-# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
-from abc import abstractmethod, ABC
-from enum import Enum
-from typing import Dict
-
-import click
-import sys
-
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot import TaskOrchestrator, \
-    ResourceTaskRequest, TaskRequestType, TaskConfiguration
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.bundle_helper import BundleHelper
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.constants import \
-    MESH_CUSTOM_RESOURCE_DICT
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.helper import MeshTaskException
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.messages import Messages
-
-
-class DebugHandlerRequestType(Enum):
-    K8S_CHECK = 'K8S_CHECK'
-    K8S_CHECK_CONTEXT = 'K8S_CHECK_CONTEXT'
-    OCID_VALIDATION = 'OCID_VALIDATION'
-    BUNDLE_NAME = 'BUNDLE_NAME'
-    BUNDLE_COMPRESS = 'BUNDLE_COMPRESS'
-    BUNDLE_CLEANUP = 'BUNDLE_CLEANUP'
-    TASK = 'TASK'
-
-
-class ResultIdentifier(Enum):
-    BUNDLE_NAME = 'bundle_name'
-    CURRENT_CONTEXT = 'current_context'
-    K8S_CONTEXT = 'k8s_context'
-
-
-class ResultStatus(Enum):
-    OK = '200'
-    NOT_FOUND = '404'
-    INTERNAL_ERROR = '500'
-
-
-class Result:
-    def __init__(self, status: ResultStatus, data: Dict = None, exception: str = None):
-        self.status = status
-        self.data = data
-        self.exception = exception
-
-
-class DebugHandler(ABC):
-    @abstractmethod
-    def set_next(self, debug_handler):
-        pass
-
-    @abstractmethod
-    def handle(self, request: Dict) -> Result:
-        pass
-
-
-class AbstractDebugHandler(DebugHandler):
-    _next_handler: DebugHandler = None
-
-    def set_next(self, debug_handler: DebugHandler) -> DebugHandler:
-        self._next_handler = debug_handler
-        return debug_handler
-
-    @abstractmethod
-    def handle(self, request: Dict) -> Result:
-        if self._next_handler:
-            return self._next_handler.handle(request)
-        return Result(status=ResultStatus.INTERNAL_ERROR, data={})
-
-
-class OcidValidationHandler(AbstractDebugHandler):
-    def handle(self, request: Dict) -> Result:
-        request_type = request['type']
-        if request_type == DebugHandlerRequestType.OCID_VALIDATION:
-            ocid = request['data']['ocid']
-            if ocid is None:
-                click.echo(Messages.is_none.format('ocid'), file=sys.stderr)
-                return Result(status=ResultStatus.NOT_FOUND, exception=Messages.is_none.format('ocid'))
-
-            # Split the token to get the resource type
-            ocid_tokens = ocid.split(".")
-
-            # Validate ocid format
-            if len(ocid_tokens) < 2:
-                # raise click.BadParameter(Messages.invalid_ocid)
-                exception = Messages.invalid_ocid
-                click.echo(exception, file=sys.stderr)
-                return Result(status=ResultStatus.INTERNAL_ERROR, exception=exception)
-
-            # Validate mesh resource type
-            resource_type = ocid_tokens[1]
-            try:
-                MESH_CUSTOM_RESOURCE_DICT[resource_type]
-            except Exception as error:
-                exception = Messages.invalid_mesh_resource_type.format(resource_type) + '. ' + str(error)
-                click.echo(exception, file=sys.stderr)
-                return Result(status=ResultStatus.INTERNAL_ERROR, exception=exception)
-
-            # Is a valid ocid
-            return Result(status=ResultStatus.OK, data={})
-        else:
-            return super(OcidValidationHandler, self).handle(request)
-
-
-class K8sCheckHandler(AbstractDebugHandler):
-    def handle(self, request: Dict) -> Result:
-        request_type = request['type']
-        if request_type == DebugHandlerRequestType.K8S_CHECK:
-            kube_command_helper = request['kube_command_helper']
-            kube_command_summary = kube_command_helper.is_kubectl_installed()
-            if kube_command_summary.return_code == 0:
-                return Result(status=ResultStatus.OK, data={})
-            else:
-                return Result(status=ResultStatus.NOT_FOUND, exception=kube_command_summary.stderr)
-        else:
-            return super(K8sCheckHandler, self).handle(request)
-
-
-class K8sCheckContextHandler(AbstractDebugHandler):
-    def handle(self, request: Dict) -> Result:
-        request_type = request['type']
-        if request_type == DebugHandlerRequestType.K8S_CHECK_CONTEXT:
-            kube_command_helper = request['kube_command_helper']
-            k8s_context = request['data'][ResultIdentifier.K8S_CONTEXT.value]
-            k8s_config, use_context = k8s_context
-            kube_command_summary = kube_command_helper.check_context(k8s_context)
-            if kube_command_summary.return_code != 0:
-                return Result(status=ResultStatus.INTERNAL_ERROR, exception=kube_command_summary.stderr)
-            else:
-                return Result(status=ResultStatus.OK)
-        else:
-            return super(K8sCheckContextHandler, self).handle(request)
-
-
-class BundleNameHandler(AbstractDebugHandler):
-    def handle(self, request: Dict) -> Result:
-        request_type = request['type']
-        if request_type == DebugHandlerRequestType.BUNDLE_NAME:
-            bundle_name = BundleHelper.get_bundle_name()
-            return Result(status=ResultStatus.OK, data={ResultIdentifier.BUNDLE_NAME: bundle_name})
-        else:
-            return super(BundleNameHandler, self).handle(request)
-
-
-class BundleCompressHandler(AbstractDebugHandler):
-    def handle(self, request: Dict) -> Result:
-        request_type = request['type']
-        if request_type == DebugHandlerRequestType.BUNDLE_COMPRESS:
-            try:
-                directory_name = request['data']['directory_name']
-                bundle_name = request['data']['bundle_name']
-                BundleHelper.compress_bundle(directory_name, bundle_name)
-                if BundleHelper.compress_bundle(directory_name, bundle_name) is False:
-                    raise MeshTaskException()
-                else:
-                    return Result(status=ResultStatus.OK)
-            except MeshTaskException:
-                return Result(status=ResultStatus.INTERNAL_ERROR, exception='***Generating Bundle failed. Directory path not found***')
-            except Exception as error:
-                exception = Messages.some_exception.format(request_type, error)
-                click.echo(exception, file=sys.stderr)
-                return Result(status=ResultStatus.INTERNAL_ERROR, exception=exception)
-        else:
-            return super(BundleCompressHandler, self).handle(request)
-
-
-class BundleCleanupHandler(AbstractDebugHandler):
-    def handle(self, request: Dict) -> Result:
-        request_type = request['type']
-        if request_type == DebugHandlerRequestType.BUNDLE_CLEANUP:
-            try:
-                directory_name = request['data']['directory_name']
-                bundle_name = request['data']['bundle_name']
-                BundleHelper.cleanup(directory_name, bundle_name)
-                return Result(status=ResultStatus.OK)
-            except Exception as error:
-                exception = Messages.some_exception.format(request_type, error)
-                click.echo(exception, file=sys.stderr)
-                return Result(status=ResultStatus.INTERNAL_ERROR, exception=exception)
-        else:
-            return super(BundleCleanupHandler, self).handle(request)
-
-
-class TaskHandler(AbstractDebugHandler):
-    def __init__(self, thread_pool_size=None):
-        self.thread_pool_size = thread_pool_size
-
-    def handle(self, request: Dict) -> Result:
-        request_type = request['type']
-        if request_type == DebugHandlerRequestType.TASK:
-            ocid = request['data']['ocid']
-            k8s_context = request['data']['k8s_context']
-            # if ocid is None:
-            #     return Result(status=ResultStatus.NOT_FOUND, data={})
-            try:
-                task_orchestrator = TaskOrchestrator(ocid, k8s_context, self.thread_pool_size)
-                resource_task = ResourceTaskRequest(TaskRequestType.RESOURCE_PROCESSOR,
-                                                    [TaskConfiguration.CHILD_RESOURCES],
-                                                    ocid)
-                task_orchestrator.process_tasks([resource_task])
-                return Result(status=ResultStatus.OK, data={})
-            except Exception as error:
-                exception = Messages.some_exception.format(request_type, error)
-                click.echo(exception, file=sys.stderr)
-                return Result(status=ResultStatus.INTERNAL_ERROR, exception=exception)
-        else:
-            return super(TaskHandler, self).handle(request)