CIRV-Cleanup: Remove HDV and SDV contents.

As CIRV-HDV and CIRV-SDV are active now, we do not need contents here.
The docs folder has links to HDV and SDV.

Signed-off-by: Sridhar K. N. Rao <sridhar.rao@spirent.com>
Change-Id: I86ee90fb5e969e14d000d9a08d971b13a2c2740e

1 files changed, 0 insertions, 183 deletions

diff --git a/tools/sdv/core/loader/loader_servant.py b/tools/sdv/core/loader/loader_servant.py
deleted file mode 100644
index 4e55c67..0000000
--- a/tools/sdv/core/loader/loader_servant.py
+++ /dev/null
@@ -1,183 +0,0 @@
-# Copyright 2020 Intel Corporation, Spirent Communications.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Loader Support Module.
-"""
-
-import os
-from os import sys
-import imp
-import fnmatch
-import logging
-from conf import settings
-
-
-class LoaderServant():
-    """Class implements basic dynamic import operations.
-    """
-    _class_name = None
-    _path = None
-    _interface = None
-
-    def __init__(self, path, class_name, interface):
-        """LoaderServant constructor
-
-        Intializes all data needed for import operations.
-
-        Attributes:
-            path: path to directory which contains implementations derived from
-                    interface.
-            class_name: Class name which will be returned in get_class
-                        method, if such definition exists in directory
-                        represented by path,
-            interface: interface type. Every object which doesn't
-                        implement this particular interface will be
-                        filtered out.
-        """
-        self._class_name = class_name
-        self._path = path
-        self._interface = interface
-
-    def get_class(self):
-        """Returns class type based on parameters passed in __init__.
-
-        :return: Type of the found class.
-            None if class hasn't been found
-        """
-
-        return self.load_module(path=self._path,
-                                interface=self._interface,
-                                class_name=self._class_name)
-
-    def get_classes(self):
-        """Returns all classes in path derived from interface
-
-        :return: Dictionary with following data:
-            - key: String representing class name,
-            - value: Class type.
-        """
-        return self.load_modules(path=self._path,
-                                 interface=self._interface)
-
-    def get_classes_printable(self):
-        """Returns all classes derived from _interface found in path
-
-        :return: String - list of classes in printable format.
-        """
-
-        out = self.load_modules(path=self._path,
-                                interface=self._interface)
-        results = []
-
-        # sort modules to produce the same output everytime
-        for (name, mod) in sorted(out.items()):
-            desc = (mod.__doc__ or 'No description').strip().split('\n')[0]
-            results.append((name, desc))
-
-        header = 'Classes derived from: ' + self._interface.__name__
-        output = [header + '\n' + '=' * len(header) + '\n']
-
-        for (name, desc) in results:
-            output.append('* %-18s%s' % ('%s:' % name, desc))
-
-            output.append('')
-
-        output.append('')
-
-        return '\n'.join(output)
-
-    @staticmethod
-    def load_module(path, interface, class_name):
-        """Imports everything from given path and returns class type
-
-        This is based on following conditions:
-            - Class is derived from interface,
-            - Class type name matches class_name.
-
-        :return: Type of the found class.
-            None if class hasn't been found
-        """
-
-        results = LoaderServant.load_modules(
-            path=path, interface=interface)
-
-        if class_name in results:
-            logging.info(
-                "Class found: %s.", class_name)
-            return results.get(class_name)
-
-        return None
-
-    @staticmethod
-    def load_modules(path, interface):
-        """Returns dictionary of class name/class type found in path
-
-        This is based on following conditions:
-            - classes found under path are derived from interface.
-            - class is not interface itself.
-
-        :return: Dictionary with following data:
-            - key: String representing class name,
-            - value: Class type.
-        """
-        result = {}
-
-        for _, mod in LoaderServant._load_all_modules(path):
-            # find all classes derived from given interface, but suppress
-            # interface itself and any abstract class starting with iface name
-            gens = dict((k, v) for (k, v) in list(mod.__dict__.items())
-                        if isinstance(v, type) and
-                        issubclass(v, interface) and
-                        not k.startswith(interface.__name__))
-            if gens:
-                for (genname, gen) in list(gens.items()):
-                    result[genname] = gen
-        return result
-
-    @staticmethod
-    def _load_all_modules(path):
-        """Load all modules from ``path`` directory.
-
-        This is based on the design used by OFTest:
-            https://github.com/floodlight/oftest/blob/master/oft
-
-        :param path: Path to a folder of modules.
-
-        :return: List of modules in a folder.
-        """
-        mods = []
-
-        for root, _, filenames in os.walk(path):
-            # Iterate over each python file
-            for filename in fnmatch.filter(filenames, '[!.]*.py'):
-                modname = os.path.splitext(os.path.basename(filename))[0]
-
-                # skip module load if it is excluded by configuration
-                if modname in settings.getValue('EXCLUDE_MODULES'):
-                    continue
-
-                try:
-                    if modname in sys.modules:
-                        mod = sys.modules[modname]
-                    else:
-                        mod = imp.load_module(
-                            modname, *imp.find_module(modname, [root]))
-                except ImportError:
-                    logging.error('Could not import file %s', filename)
-                    raise
-
-                mods.append((modname, mod))
-
-        return mods