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_troubleshoot/tasks/mesh_report_worker.py

@@ -1,60 +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 click
-
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.task_request import TaskRequest, \
-    TaskRequestType, TaskConfiguration, NamespacesTaskRequest, CommonTaskRequest, OciCliVersionTaskRequest, \
-    ValidateCrdsTaskRequest, WebhooksTaskRequest, ServicesTaskRequest
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.task_worker import MeshTask
-
-
-class MeshReportTask(MeshTask):
-    def __init__(self, k8s_context=None):
-        super(MeshReportTask, self).__init__(TaskRequestType.MESH_REPORT_PROCESSOR)
-        self.k8s_context = k8s_context
-
-    def do_work(self, task_request: TaskRequest, kube_command_helper):
-        data = task_request.get_task_data()
-        mesh_id = data['mesh_id']
-        output_events, tasks = [], []
-        try:
-            # OCI CLI VERSION
-            oci_cli_version_task_request = OciCliVersionTaskRequest(TaskRequestType.OCI_CLI_VERSION_PROCESSOR,
-                                                                    [],
-                                                                    mesh_id)
-            tasks.append(oci_cli_version_task_request)
-
-            # OSOK, OLM, CM, METRICS_SERVER and CATALOG_PROCESSOR
-            for task_request_identifier in [TaskRequestType.OSOK_PROCESSOR, TaskRequestType.OLM_PROCESSOR,
-                                            TaskRequestType.METRICS_PROCESSOR, TaskRequestType.CATALOG_PROCESSOR]:
-                task_configurations = [TaskConfiguration.POD_SUMMARY]
-                if task_request_identifier in [TaskRequestType.OSOK_PROCESSOR, TaskRequestType.OLM_PROCESSOR,
-                                               TaskRequestType.CATALOG_PROCESSOR]:
-                    task_configurations.append(TaskConfiguration.LOGS)
-                generic_task_request = CommonTaskRequest(TaskRequestType.COMMON_PROCESSOR,
-                                                         task_configurations,
-                                                         mesh_id,
-                                                         task_request_identifier)
-                tasks.append(generic_task_request)
-
-            # CRDs installed
-            validate_crds_task_request = ValidateCrdsTaskRequest(TaskRequestType.VALIDATE_CRDS_PROCESSOR, [], mesh_id)
-            tasks.append(validate_crds_task_request)
-
-            # webhooks
-            webhooks_task_request = WebhooksTaskRequest(TaskRequestType.WEBHOOKS_PROCESSOR, [], mesh_id)
-            tasks.append(webhooks_task_request)
-
-            # check services
-            services_task_request = ServicesTaskRequest(TaskRequestType.SERVICES_PROCESSOR, [], mesh_id)
-            tasks.append(services_task_request)
-
-            # Sidecar injection enabled namespaces
-            namespaces_task_request = NamespacesTaskRequest(TaskRequestType.NAMESPACES_PROCESSOR, [], mesh_id)
-            tasks.append(namespaces_task_request)
-
-            return tasks, output_events
-
-        except Exception as error:
-            click.echo('MeshReportTask Exception: {}'.format(error))

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/tasks/mesh_resources_worker.py

@@ -1,49 +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 click
-
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.task_request import TaskRequest, \
-    TaskRequestType
-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.utils.bundle_helper import \
-    save_custom_resource_as_yaml
-
-
-class MeshResourcesTask(MeshTask):
-    def __init__(self, k8s_context=None):
-        super(MeshResourcesTask, self).__init__(TaskRequestType.MESH_RESOURCES_PROCESSOR)
-        self.k8s_context = k8s_context
-
-    def do_work(self, task_request: TaskRequest, kube_command_helper):
-        tasks, output_events = [], []
-        try:
-            data = task_request.get_task_data()
-            mesh_id = data['mesh_id']
-
-            # Fetch all the mesh resources and save as yaml
-            mesh_resources = kube_command_helper.parallel_filter_mesh_resources(mesh_id)
-            all_crds = []
-            for mesh_id, crd_list in mesh_resources.mesh_dict.items():
-                all_crds.extend(crd_list)
-            for vs_id, crd_list in mesh_resources.vs_dict.items():
-                all_crds.extend(crd_list)
-            for vd_id, crd_list in mesh_resources.vd_dict.items():
-                all_crds.extend(crd_list)
-            for vdb_id, crd_list in mesh_resources.vdb_dict.items():
-                all_crds.extend(crd_list)
-            for vsrt_id, crd_list in mesh_resources.vsrt_dict.items():
-                all_crds.extend(crd_list)
-            for ig_id, crd_list in mesh_resources.ig_dict.items():
-                all_crds.extend(crd_list)
-            for igrt_id, crd_list in mesh_resources.igrt_dict.items():
-                all_crds.extend(crd_list)
-            for ap_id, crd_list in mesh_resources.ap_dict.items():
-                all_crds.extend(crd_list)
-
-            for crd in all_crds:
-                save_custom_resource_as_yaml(mesh_id, crd)
-            return tasks, output_events
-
-        except Exception as error:
-            click.echo('MeshResourcesTask Exception: {}'.format(error))

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/tasks/namespaces_worker.py

@@ -1,33 +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 click
-
-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_request import TaskRequest, \
-    TaskRequestType
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.task_worker import MeshTask
-
-
-class NamespacesTask(MeshTask):
-    def __init__(self, k8s_context=None):
-        super(NamespacesTask, self).__init__(TaskRequestType.NAMESPACES_PROCESSOR)
-        self.k8s_context = k8s_context
-
-    def do_work(self, task_request: TaskRequest, kube_command_helper):
-        output_events, tasks = [], []
-        try:
-            data = task_request.get_task_data()
-            mesh_id = data['mesh_id']
-
-            sidecar_enabled_namespaces = kube_command_helper.get_namespaces_with_sidecar_injection_enabled()
-            event = Event(event_type=EventType.SIDECAR_INJECTION_ENABLED_NAMESPACES,
-                          operations={OperationType.STORE_SINGLE_EVENT},
-                          data=sidecar_enabled_namespaces,
-                          identifications={mesh_id: None},
-                          store={mesh_id})
-            output_events.append(event)
-            return tasks, output_events
-        except Exception as error:
-            click.echo('NamespacesTask Exception: {}'.format(error))

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/tasks/oci_cli_version_worker.py

@@ -1,34 +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 click
-import oci
-
-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_request import TaskRequest, \
-    TaskRequestType
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.task_worker import MeshTask
-
-
-class OciCliVersionTask(MeshTask):
-    def __init__(self, k8s_context=None):
-        super(OciCliVersionTask, self).__init__(TaskRequestType.OCI_CLI_VERSION_PROCESSOR)
-        self.k8s_context = k8s_context
-
-    def do_work(self, task_request: TaskRequest, kube_command_helper):
-        output_events, tasks = [], []
-        try:
-            data = task_request.get_task_data()
-            mesh_id = data['mesh_id']
-
-            oci_cli_version = oci.__version__
-            event = Event(event_type=EventType.OCI_CLI_VERSION,
-                          operations={OperationType.STORE_SINGLE_EVENT},
-                          data=oci_cli_version,
-                          identifications={mesh_id: None},
-                          store={mesh_id})
-            output_events.append(event)
-            return tasks, output_events
-        except Exception as error:
-            click.echo('OciCliVersionTask Exception: {}'.format(error))

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/tasks/pod_worker.py

@@ -1,112 +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 click
-
-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_request import TaskRequestType, \
-    TaskConfiguration, TaskRequest, FileTaskRequest
-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.utils.bundle_helper import \
-    BundleHelper
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.summary import MeshData, PodSummary
-
-
-class PodTask(MeshTask):
-    def __init__(self, k8s_context=None):
-        super(PodTask, self).__init__(TaskRequestType.POD_PROCESSOR)
-        self.k8s_context = k8s_context
-
-    def do_work(self, task_request: TaskRequest, kube_command_helper):
-        output_events, tasks = [], []
-        try:
-            data = task_request.get_task_data()
-            pod_summary = data['pod_summary']
-            mesh_data = data['mesh_data']
-            name = pod_summary.basic_pod_summary.name
-            namespace = pod_summary.basic_pod_summary.namespace
-            relative_path = None
-            if mesh_data.vdb_key is not None:
-                relative_path = mesh_data.get_virtual_deployment_binding_hierarchy()
-            elif mesh_data.igd_key is not None:
-                relative_path = mesh_data.get_ingress_gateway_deployment_hierarchy()
-
-            # Run the relevant configurations
-            for task_configuration in task_request.configurations:
-                if task_configuration == TaskConfiguration.LOGS:
-                    proxy_logs = kube_command_helper.get_proxy_logs(name, namespace)
-                    proxy_log_file_name = BundleHelper.get_proxy_log_file_name(name, namespace)
-                    if proxy_logs is not None:
-                        logs_file_task_request = FileTaskRequest(TaskRequestType.FILE_PROCESSOR,
-                                                                 [],
-                                                                 relative_path,
-                                                                 proxy_log_file_name,
-                                                                 proxy_logs)
-                        tasks.append(logs_file_task_request)
-
-                if task_configuration == TaskConfiguration.CONFIG_DUMP:
-                    config_dump = kube_command_helper.get_config_dump(name, namespace)
-                    config_dump_file_name = BundleHelper.get_config_dump_file_name(name, namespace)
-                    if config_dump is not None:
-                        config_dump_file_task_request = FileTaskRequest(TaskRequestType.FILE_PROCESSOR,
-                                                                        [],
-                                                                        relative_path,
-                                                                        config_dump_file_name,
-                                                                        config_dump)
-
-                        tasks.append(config_dump_file_task_request)
-                        pod_summary.dynamic_config_version = self.get_dynamic_cluster_version_from_config(config_dump)
-
-                # Proxy Stats
-                if task_configuration == TaskConfiguration.PROXY_STATS:
-                    proxy_stats = kube_command_helper.get_proxy_stats(name, namespace)
-                    proxy_stats_file_name = BundleHelper.get_proxy_stats_file_name(name, namespace)
-                    if proxy_stats is not None:
-                        proxy_stats_file_task_request = FileTaskRequest(TaskRequestType.FILE_PROCESSOR,
-                                                                        [],
-                                                                        relative_path,
-                                                                        proxy_stats_file_name,
-                                                                        proxy_stats)
-                        tasks.append(proxy_stats_file_task_request)
-
-                    # Queue output events
-                    output_events = output_events + self.generate_and_queue_output_events(pod_summary, mesh_data)
-
-            return tasks, output_events
-        except Exception as error:
-            click.echo('PodTask Exception: {}'.format(error))
-
-    def get_dynamic_cluster_version_from_config(self, config_dump):
-        version_info = None
-        if config_dump is None or config_dump["configs"] is None:
-            return None
-
-        for dump in config_dump["configs"]:
-            if dump["@type"] == "type.googleapis.com/envoy.admin.v3.ClustersConfigDump":
-                dynamic_active_clusters = dump["dynamic_active_clusters"]
-                if len(dynamic_active_clusters) > 0:
-                    version_info = dynamic_active_clusters[0]["version_info"]
-                    break
-        return version_info
-
-    @staticmethod
-    def generate_and_queue_output_events(pod_summary: PodSummary,
-                                         mesh_data: MeshData):
-        output_events = []
-        if pod_summary is None or mesh_data is None:
-            return
-
-        store = {}
-        if mesh_data.ig_id is not None:
-            store = {mesh_data.mesh_id, mesh_data.ig_id}
-        elif mesh_data.vd_id is not None:
-            store = {mesh_data.mesh_id, mesh_data.vs_id, mesh_data.vd_id}
-        event = Event(event_type=EventType.POD_SUMMARY,
-                      operations={OperationType.STORE_MULTI_EVENT},
-                      data=pod_summary.to_dict(mesh_data),
-                      identifications=mesh_data.get_hierarchy_as_dict(),
-                      store=store)
-        output_events.append(event)
-        return output_events

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/tasks/resource_worker.py

@@ -1,75 +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 click
-
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.task_request import TaskRequestType, \
-    VdbTaskRequest, TaskConfiguration, IgdTaskRequest, MeshReportTaskRequest, MeshResourcesTaskRequest
-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.utils.constants import VS_PLURAL, \
-    MESH_PLURAL, VD_PLURAL, IG_PLURAL
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.helper import \
-    get_resource_type_from_ocid, MeshTaskException
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.messages import Messages
-
-
-class ResourceTask(MeshTask):
-    def __init__(self, k8s_context=None):
-        super(ResourceTask, self).__init__(TaskRequestType.RESOURCE_PROCESSOR)
-        self.k8s_context = k8s_context
-
-    def do_work(self, task_request, kube_command_helper):
-        output_events, tasks = [], []
-        try:
-            data = task_request.get_task_data()
-            resource_id = data['resource_id']
-            if resource_id is None:
-                # Mesh Report Task
-                mesh_report_task_request = MeshReportTaskRequest(TaskRequestType.MESH_REPORT_PROCESSOR, [], resource_id)
-                tasks.append(mesh_report_task_request)
-
-            else:
-                resource_type = get_resource_type_from_ocid(resource_id)
-                meshes_list = []
-
-                # VDBs
-                if resource_type in [VS_PLURAL, VD_PLURAL, MESH_PLURAL]:
-                    mesh_vdb_dict = kube_command_helper.filter_vdbs_by_ocid(resource_id)
-                    vdb_pods_dict = kube_command_helper.filter_all_pods_related_to_vdbs()
-                    if len(mesh_vdb_dict) > 0:
-                        binding_task_request = VdbTaskRequest(TaskRequestType.VDB_PROCESSOR,
-                                                              [TaskConfiguration.CHILD_RESOURCES],
-                                                              mesh_vdb_dict,
-                                                              vdb_pods_dict)
-                        tasks.append(binding_task_request)
-                    meshes_list = meshes_list + list(mesh_vdb_dict.keys())
-
-                # IGDs
-                if resource_type in [IG_PLURAL, MESH_PLURAL]:
-                    mesh_igd_dict = kube_command_helper.filter_igds_by_ocid(resource_id)
-                    igd_pods_dict = kube_command_helper.filter_all_pods_related_to_igds()
-                    if len(mesh_igd_dict) > 0:
-                        igd_task_request = IgdTaskRequest(TaskRequestType.IGD_PROCESSOR,
-                                                          [TaskConfiguration.CHILD_RESOURCES],
-                                                          mesh_igd_dict,
-                                                          igd_pods_dict)
-                        tasks.append(igd_task_request)
-                    meshes_list = meshes_list + list(mesh_igd_dict.keys())
-                meshes = set(meshes_list)
-                if len(meshes) > 0:
-                    for mesh_id in meshes:
-                        # Mesh Report Task
-                        mesh_report_task_request = MeshReportTaskRequest(TaskRequestType.MESH_REPORT_PROCESSOR, [], mesh_id)
-                        tasks.append(mesh_report_task_request)
-
-                        # Mesh Resources Task
-                        mesh_resources_task_request = MeshResourcesTaskRequest(TaskRequestType.MESH_RESOURCES_PROCESSOR,
-                                                                               [], mesh_id)
-                        tasks.append(mesh_resources_task_request)
-            if not tasks and not output_events:
-                raise MeshTaskException()
-            return tasks, output_events
-        except MeshTaskException:
-            click.echo(Messages.is_invalid)
-        except Exception as error:
-            click.echo('ResourceTask Exception: {}'.format(error))

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/tasks/services_worker.py

@@ -1,34 +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 click
-
-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_request import TaskRequest, \
-    TaskRequestType
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.task_worker import MeshTask
-
-
-class CheckServicesTask(MeshTask):
-    def __init__(self, k8s_context=None):
-        super(CheckServicesTask, self).__init__(TaskRequestType.SERVICES_PROCESSOR)
-        self.k8s_context = k8s_context
-
-    def do_work(self, task_request: TaskRequest, kube_command_helper):
-        output_events, tasks = [], []
-        try:
-            data = task_request.get_task_data()
-            mesh_id = data['mesh_id']
-
-            services_list = kube_command_helper.get_operator_services()
-            event = Event(EventType.OPERATOR_SERVICES,
-                          operations={OperationType.STORE_SINGLE_EVENT},
-                          data=services_list,
-                          identifications={mesh_id: None},
-                          store={mesh_id})
-            output_events.append(event)
-            return tasks, output_events
-
-        except Exception as error:
-            click.echo('ServicesTask Exception: {}'.format(error))

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/tasks/task_worker.py

@@ -1,33 +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 queue
-from abc import abstractmethod
-from typing import List
-
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot import Event
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.task_request import TaskRequestType, \
-    TaskRequest
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.utils.kubectl_command_helper import \
-    KubeCommandHelper
-
-
-class MeshTask(object):
-    def __init__(self, task_request_type: TaskRequestType, k8s_context=None):
-        self.task_request_type = task_request_type
-        self.k8s_context = k8s_context
-
-    @abstractmethod
-    def do_work(self, task_request: TaskRequest, kube_command_helper: KubeCommandHelper) -> (
-            List[TaskRequest], List[Event]):
-        raise NotImplementedError('do_work() is not implemented')
-
-    def execute(self, task_request: TaskRequest, output_events: queue.Queue, tasks: queue.Queue):
-        if self.task_request_type != task_request.task_request_type:
-            raise RuntimeError("Wrong request Type routed")
-        kube_command_helper = KubeCommandHelper(self.k8s_context)
-        next_tasks, events = self.do_work(task_request, kube_command_helper)
-        for task in next_tasks:
-            tasks.put(task)
-        for event in events:
-            output_events.put(event)

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/tasks/validate_crds_worker.py

@@ -1,34 +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 click
-
-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_request import TaskRequest, \
-    TaskRequestType
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.task_worker import MeshTask
-
-
-class ValidateCrdsTask(MeshTask):
-    def __init__(self, k8s_context=None):
-        super(ValidateCrdsTask, self).__init__(TaskRequestType.VALIDATE_CRDS_PROCESSOR)
-        self.k8s_context = k8s_context
-
-    def do_work(self, task_request: TaskRequest, kube_command_helper):
-        output_events, tasks = [], []
-        try:
-            data = task_request.get_task_data()
-            mesh_id = data['mesh_id']
-
-            validated_crds_list = kube_command_helper.get_crds_validated()
-            event = Event(EventType.SERVICE_MESH_CRDS,
-                          operations={OperationType.STORE_SINGLE_EVENT},
-                          data=validated_crds_list,
-                          identifications={mesh_id: None},
-                          store={mesh_id})
-            output_events.append(event)
-            return tasks, output_events
-
-        except Exception as error:
-            click.echo('ValidateCrdsTask Exception: {}'.format(error))

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/tasks/vdb_worker.py

@@ -1,51 +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 click
-
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.task_request import TaskRequestType, \
-    PodTaskRequest, TaskConfiguration
-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.utils.summary import MeshData
-
-TASK_CONFIGURATIONS = [
-    TaskConfiguration.LOGS,
-    TaskConfiguration.CONFIG_DUMP,
-    TaskConfiguration.PROXY_STATS,
-    TaskConfiguration.POD_SUMMARY
-]
-
-
-class VdbTask(MeshTask):
-    def __init__(self, k8s_context=None):
-        super(VdbTask, self).__init__(TaskRequestType.VDB_PROCESSOR)
-        self.k8s_context = k8s_context
-
-    def do_work(self, task_request, kube_command_helper):
-        output_events, tasks = [], []
-        try:
-            data = task_request.get_task_data()
-            mesh_dict = data['mesh_dict']
-            vdb_pods_dict = data['vdb_pods_dict']
-
-            # Loop through all the Meshes
-            for mesh_id, vs_dict in mesh_dict.items():
-                # Loop through all VS under Mesh
-                for vs_id, vd_dict in vs_dict.items():
-                    # Loop through all VD under VS
-                    for vd_id, vdb_list in vd_dict.items():
-                        # Loop through the VDBs
-                        for vdb_ref in vdb_list:
-                            vdb_pods_list = vdb_pods_dict.get(vdb_ref)
-                            # Iterate through all the pods
-                            for pod_summary in vdb_pods_list:
-                                # Append the pod_task_request to tasks queue
-                                mesh_data = MeshData(mesh_id=mesh_id, vs_id=vs_id, vd_id=vd_id, vdb_key=vdb_ref)
-                                pod_task_request = PodTaskRequest(TaskRequestType.POD_PROCESSOR,
-                                                                  TASK_CONFIGURATIONS,
-                                                                  pod_summary,
-                                                                  mesh_data)
-                                tasks.append(pod_task_request)
-            return tasks, output_events
-        except Exception as error:
-            click.echo('VdbTask Exception: {}'.format(error))

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/tasks/webhooks_worker.py

@@ -1,34 +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 click
-
-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_request import TaskRequest, \
-    TaskRequestType
-from services.service_mesh.src.oci_cli_service_mesh.service_mesh_troubleshoot.tasks.task_worker import MeshTask
-
-
-class WebhooksTask(MeshTask):
-    def __init__(self, k8s_context=None):
-        super(WebhooksTask, self).__init__(TaskRequestType.WEBHOOKS_PROCESSOR)
-        self.k8s_context = k8s_context
-
-    def do_work(self, task_request: TaskRequest, kube_command_helper):
-        output_events, tasks = [], []
-        try:
-            data = task_request.get_task_data()
-            mesh_id = data['mesh_id']
-
-            webhooks_list = kube_command_helper.get_webhooks_validated()
-            event = Event(EventType.SERVICE_MESH_WEBHOOKS,
-                          operations={OperationType.STORE_SINGLE_EVENT},
-                          data=webhooks_list,
-                          identifications={mesh_id: None},
-                          store={mesh_id})
-            output_events.append(event)
-            return tasks, output_events
-
-        except Exception as error:
-            click.echo('WebhooksTask Exception: {}'.format(error))

services/service_mesh/src/oci_cli_service_mesh/service_mesh_troubleshoot/utils/__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.