chore: Removes unused code

- `coriolis/minion_manager/rpc/client.py`:
  `set_up_shared_minion_pool_resources` and `tear_down_shared_minion_pool_resources`
  were never tied to anything on the server side. Commit 2599ca85 introduced
  them as part of a refactor, with the server side commented out, which
  was later on removed in d20c6708. The client side survived, unused.
- `/coriolis/minion_manager/rpc/utils.py`: `minion_machine_synchronized`
  is not referenced. Most minion-related operations use the minion_pool_synchronized_op
  decorator instead, or minion_manager_utils.get_minion_pool_lock() (e.g.: deallocate_minion_machine).
- `coriolis/providers/backup_writers.py`: `_fetch_remote_file` private
  method, unused.
- `coriolis/scheduler/scheduler_utils.py`: not referenced anywhere.
- `coriolis/schemas_exceptions.py`: not referenced anywhere.
- `coriolis/taskflow/base.py`: private methods, unused.
- `coriolis/worker/rpc/server.py`: `_check_remove_dir` private method,
  unused.
- `coriolis/conductor/rpc/server.py`: `refresh_service_status` and its
  client side equivalent were never used since their introduction in 33c53142.

coriolis/conductor/rpc/client.py

@@ -434,10 +434,6 @@ class ConductorClient(rpc.BaseRPCClient):
             ctxt, 'check_service_registered', host=host, binary=binary,
             topic=topic)
 
-    def refresh_service_status(self, ctxt, service_id):
-        return self._call(
-            ctxt, 'refresh_service_status', service_id=service_id)
-
     def get_services(self, ctxt):
         return self._call(ctxt, 'get_services')
 

coriolis/conductor/rpc/server.py

@@ -3889,20 +3889,6 @@ class ConductorServerEndpoint(object):
                 "properties: %s", props)
         return service
 
-    @service_synchronized
-    def refresh_service_status(self, ctxt, service_id):
-        LOG.debug("Updating registration for worker service '%s'", service_id)
-        service = db_api.get_service(ctxt, service_id)
-        worker_rpc = rpc_worker_client.WorkerClient(host=service.host)
-        status = worker_rpc.get_service_status(ctxt)
-        updated_values = {
-            "providers": status["providers"],
-            "specs": status["specs"],
-            "status": constants.SERVICE_STATUS_UP}
-        db_api.update_service(ctxt, service_id, updated_values)
-        LOG.debug("Successfully refreshed status of service '%s'", service_id)
-        return db_api.get_service(ctxt, service_id)
-
     def get_services(self, ctxt):
         return db_api.get_services(ctxt)
 

coriolis/minion_manager/rpc/client.py

@@ -106,17 +106,6 @@ class MinionManagerClient(rpc.BaseRPCClient):
             minion_retention_strategy=minion_retention_strategy,
             notes=notes, skip_allocation=skip_allocation)
 
-    def set_up_shared_minion_pool_resources(self, ctxt, minion_pool_id):
-        return self._call(
-            ctxt, "set_up_shared_minion_pool_resources",
-            minion_pool_id=minion_pool_id)
-
-    def tear_down_shared_minion_pool_resources(
-            self, ctxt, minion_pool_id, force=False):
-        return self._call(
-            ctxt, "tear_down_shared_minion_pool_resources",
-            minion_pool_id=minion_pool_id, force=force)
-
     def allocate_minion_pool(self, ctxt, minion_pool_id):
         return self._call(
             ctxt, "allocate_minion_pool",

coriolis/minion_manager/rpc/utils.py

@@ -32,16 +32,3 @@ def minion_pool_synchronized_op(func):
         return minion_pool_synchronized(minion_pool_id, func)(
             self, ctxt, minion_pool_id, *args, **kwargs)
     return wrapper
-
-
-def minion_machine_synchronized(minion_pool_id, minion_machine_id, func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        @lockutils.synchronized(
-            constants.MINION_MACHINE_LOCK_NAME_FORMAT % (
-                minion_pool_id, minion_machine_id),
-            external=True)
-        def inner():
-            return func(*args, **kwargs)
-        return inner()
-    return wrapper

coriolis/providers/backup_writers.py

@@ -1071,15 +1071,6 @@ class HTTPBackupWriterBootstrapper(object):
             finally:
                 sftp.close()
 
-    def _fetch_remote_file(self, ssh, remote_file, local_file):
-        with open(local_file, 'wb') as fd:
-            utils.exec_ssh_cmd(
-                ssh,
-                "sudo chmod +r %s" % remote_file, get_pty=False)
-            data = utils.retry_on_error()(
-                utils.read_ssh_file)(ssh, remote_file)
-            fd.write(data)
-
     def _setup_certificates(self, ssh):
         remote_base_dir = "/etc/coriolis-writer"
 

coriolis/scheduler/scheduler_utils.py

@@ -1,67 +0,0 @@
-# Copyright 2016 Cloudbase Solutions Srl
-# All Rights Reserved.
-
-import random
-
-from oslo_log import log as logging
-
-from coriolis import constants
-from coriolis.db import api as db_api
-from coriolis import exception
-from coriolis.scheduler.rpc import client as rpc_scheduler_client
-from coriolis.transfer_cron.rpc import client as rpc_cron_client
-from coriolis.worker.rpc import client as rpc_worker_client
-
-
-VERSION = "1.0"
-
-LOG = logging.getLogger(__name__)
-
-RPC_TOPIC_TO_CLIENT_CLASS_MAP = {
-    constants.WORKER_MAIN_MESSAGING_TOPIC: rpc_worker_client.WorkerClient,
-    constants.SCHEDULER_MAIN_MESSAGING_TOPIC: (
-        rpc_scheduler_client.SchedulerClient),
-    constants.TRANSFER_CRON_MAIN_MESSAGING_TOPIC: (
-        rpc_cron_client.TransferCronClient)
-}
-
-
-def get_rpc_client_for_service(service, *client_args, **client_kwargs):
-    rpc_client_class = RPC_TOPIC_TO_CLIENT_CLASS_MAP.get(service.topic)
-    if not rpc_client_class:
-        raise exception.NotFound(
-            "No RPC client class for service with topic '%s'." % (
-                service.topic))
-
-    topic = service.topic
-    if service.topic == constants.WORKER_MAIN_MESSAGING_TOPIC:
-        # NOTE: coriolis.service.MessagingService-type services (such
-        # as the worker), always have a dedicated per-host queue
-        # which can be used to target the service:
-        topic = constants.SERVICE_MESSAGING_TOPIC_FORMAT % ({
-            "main_topic": constants.WORKER_MAIN_MESSAGING_TOPIC,
-            "host": service.host})
-
-    return rpc_client_class(*client_args, topic=topic, **client_kwargs)
-
-
-def get_any_worker_service(
-        scheduler_client, ctxt, random_choice=False, raw_dict=False):
-    services = scheduler_client.get_workers_for_specs(ctxt)
-    if not services:
-        raise exception.NoWorkerServiceError()
-    service = services[0]
-    if random_choice:
-        service = random.choice(services)
-    if raw_dict:
-        return service
-    return db_api.get_service(ctxt, service['id'])
-
-
-def get_worker_rpc_for_host(host, *client_args, **client_kwargs):
-    rpc_client_class = RPC_TOPIC_TO_CLIENT_CLASS_MAP[
-        constants.WORKER_MAIN_MESSAGING_TOPIC]
-    topic = constants.SERVICE_MESSAGING_TOPIC_FORMAT % ({
-        "main_topic": constants.WORKER_MAIN_MESSAGING_TOPIC,
-        "host": host})
-    return rpc_client_class(*client_args, topic=topic, **client_kwargs)

coriolis/schemas_exceptions.py

@@ -1,32 +0,0 @@
-# Copyright 2016 Cloudbase Solutions Srl
-# All Rights Reserved.
-
-"""Defines a set of exceptions possible during schema loading/validation."""
-
-import jinja2
-import jsonschema
-
-from coriolis import exception
-
-
-class CoriolisSchemaException(exception.CoriolisException):
-    """Base class for all coriolis schema handling exceptions."""
-    message = "Exception occured during schema validation: %(msg)s."
-
-
-class CoriolisSchemaValidationError(
-        CoriolisSchemaException, jsonschema.ValidationError):
-    """Raised when a schema validation has failed."""
-    message = "Failed to validate JSON schema: %(msg)s."
-
-
-class CoriolisSchemaParsingError(
-        CoriolisSchemaException, ValueError):
-    """Raised when decoding a JSON schema or when validating a JSON value."""
-    message = "Failed to parse JSON for schema validation: %(msg)s."
-
-
-class CoriolisSchemaLoadingException(
-        CoriolisSchemaException, jinja2.TemplateNotFound):
-    """Raised when schema files are not found."""
-    message = "Failed to load schema: %(msg)s."

coriolis/taskflow/base.py

@@ -9,7 +9,6 @@ from taskflow.types import failure
 from coriolis import constants
 from coriolis import exception
 from coriolis.scheduler.rpc import client as rpc_scheduler_client
-from coriolis.tasks import factory as tasks_factory
 from coriolis import utils
 from coriolis.worker.rpc import client as rpc_worker_client
 
@@ -124,61 +123,6 @@ class BaseRunWorkerTask(BaseCoriolisTaskflowTask):
                 rpc_scheduler_client.SchedulerClient())
         return self._scheduler_client_instance
 
-    def _set_provides_for_dependencies(self, kwargs):
-        dep = TASK_RETURN_VALUE_FORMAT % self._task_name
-        if kwargs.get('provides') is not None:
-            kwargs['provides'].append(dep)
-        else:
-            kwargs['provides'] = [dep]
-
-    def _set_requires_for_dependencies(self, kwargs, depends_on):
-        dep_requirements = [
-            TASK_RETURN_VALUE_FORMAT % dep_id
-            for dep_id in depends_on]
-        if kwargs.get('requires') is not None:
-            kwargs['requires'].extend(dep_requirements)
-        elif dep_requirements:
-            kwargs['requires'] = dep_requirements
-        return kwargs
-
-    def _set_requires_for_task_info_fields(self, kwargs):
-        new_requires = kwargs.get('requires', [])
-        main_task_runner = tasks_factory.get_task_runner_class(
-            self._main_task_runner_type)
-        main_task_deps = main_task_runner.get_required_task_info_properties()
-        new_requires.extend(main_task_deps)
-        if self._cleanup_task_runner_type:
-            cleanup_task_runner = tasks_factory.get_task_runner_class(
-                self._cleanup_task_runner_type)
-            cleanup_task_deps = list(
-                set(
-                    cleanup_task_runner.get_required_task_info_properties(
-                    )).difference(
-                    main_task_runner.get_returned_task_info_properties()))
-            new_requires.extend(cleanup_task_deps)
-
-        kwargs['requires'] = new_requires
-        return kwargs
-
-    def _set_provides_for_task_info_fields(self, kwargs):
-        new_provides = kwargs.get('provides', [])
-        main_task_runner = tasks_factory.get_task_runner_class(
-            self._main_task_runner_type)
-        main_task_res = main_task_runner.get_returned_task_info_properties()
-        new_provides.extend(main_task_res)
-        if self._cleanup_task_runner_type:
-            cleanup_task_runner = tasks_factory.get_task_runner_class(
-                self._cleanup_task_runner_type)
-            cleanup_task_res = list(
-                set(
-                    cleanup_task_runner.get_returned_task_info_properties(
-                    )).difference(
-                    main_task_runner.get_returned_task_info_properties()))
-            new_provides.extend(cleanup_task_res)
-
-        kwargs['provides'] = new_provides
-        return kwargs
-
     def _get_worker_service_rpc_for_task(
             self, ctxt, task_id, task_type, origin, destination,
             retry_count=5, retry_period=2,

coriolis/tests/conductor/rpc/test_client.py

@@ -421,12 +421,6 @@ class ConductorClientTestCase(test_base.CoriolisRPCClientTestCase):
         }
         self._test(self.client.check_service_registered, args)
 
-    def test_refresh_service_status(self):
-        args = {
-            "service_id": "mock_service_id"
-        }
-        self._test(self.client.refresh_service_status, args)
-
     def test_get_services(self):
         self._test(self.client.get_services, args={})
 

coriolis/tests/conductor/rpc/test_server.py

@@ -5433,43 +5433,6 @@ class ConductorServerEndpointTestCase(test_base.CoriolisBaseTestCase):
             topic=mock.sentinel.topic
         )
 
-    @mock.patch.object(db_api, "update_service")
-    @mock.patch.object(rpc_worker_client.WorkerClient, "get_service_status")
-    @mock.patch.object(db_api, "get_service", new_callable=mock.Mock)
-    def test_refresh_service_status(
-        self,
-        mock_get_service,
-        mock_get_service_status,
-        mock_update_service
-    ):
-        result = testutils.get_wrapped_function(
-            self.server.refresh_service_status)(
-            self.server,
-            mock.sentinel.context,
-            mock.sentinel.service_id,
-        )
-        self.assertEqual(
-            mock_get_service.return_value,
-            result
-        )
-        mock_get_service.assert_has_calls([
-            mock.call(
-                mock.sentinel.context,
-                mock.sentinel.service_id
-            )
-        ] * 2)
-        mock_get_service_status.assert_called_once_with(
-            mock.sentinel.context)
-        mock_update_service.assert_called_once_with(
-            mock.sentinel.context,
-            mock.sentinel.service_id,
-            {
-                "providers": mock_get_service_status.return_value["providers"],
-                "specs": mock_get_service_status.return_value["specs"],
-                "status": constants.SERVICE_STATUS_UP
-            }
-        )
-
     @mock.patch.object(db_api, "get_services")
     def test_get_services(self, mock_get_services):
         result = self.server.get_services(mock.sentinel.context)

coriolis/tests/minion_manager/rpc/test_client.py

@@ -164,23 +164,6 @@ class MinionManagerClientTestCase(test_base.CoriolisRPCClientTestCase):
         }
         self._test(self.client.create_minion_pool, args)
 
-    def test_set_up_shared_minion_pool_resources(self):
-        args = {
-            "minion_pool_id": self.minion_pool_id
-        }
-        self._test(
-            self.client.set_up_shared_minion_pool_resources, args,
-        )
-
-    def test_tear_down_shared_minion_pool_resources(self):
-        args = {
-            "minion_pool_id": self.minion_pool_id,
-            "force": False
-        }
-        self._test(
-            self.client.tear_down_shared_minion_pool_resources, args,
-        )
-
     def test_allocate_minion_pool(self):
         args = {
             "minion_pool_id": self.minion_pool_id

coriolis/tests/providers/test_backup_writers.py

@@ -1463,20 +1463,6 @@ class HTTPBackupWriterBootstrapperTestcase(test_base.CoriolisBaseTestCase):
         mock_exec_ssh_cmd.assert_not_called()
         mock_sftp.close.assert_called_once()
 
-    @mock.patch('coriolis.utils.read_ssh_file')
-    @mock.patch('coriolis.utils.exec_ssh_cmd')
-    def test__fetch_remote_file(self, mock_exec_ssh_cmd, mock_read_ssh_file):
-        with mock.patch('builtins.open', mock.mock_open()) as data:
-            self.bootstrapper._fetch_remote_file(
-                self._ssh, mock.sentinel.remote_file, mock.sentinel.local_file)
-            data.assert_called_once_with(mock.sentinel.local_file, 'wb')
-            mock_exec_ssh_cmd.assert_called_once_with(
-                self._ssh, "sudo chmod +r %s" % mock.sentinel.remote_file,
-                get_pty=False)
-
-            data.return_value.write.assert_called_once_with(
-                mock_read_ssh_file.return_value)
-
     @mock.patch('coriolis.utils.test_ssh_path')
     @mock.patch('coriolis.utils.exec_ssh_cmd')
     def test__setup_certificates(self, mock_exec_ssh_cmd, mock_test_ssh_path):

coriolis/tests/scheduler/test_scheduler_utils.py

@@ -1,125 +0,0 @@
-# Copyright 2024 Cloudbase Solutions Srl
-# All Rights Reserved.
-
-from unittest import mock
-
-from coriolis import constants
-from coriolis import exception
-from coriolis.scheduler import scheduler_utils
-from coriolis.tests import test_base
-
-
-class CoriolisTestException(Exception):
-    pass
-
-
-class SchedulerUtilsTestCase(test_base.CoriolisBaseTestCase):
-    """Test suite for the Coriolis scheduler utils package."""
-
-    def setUp(self):
-        super(SchedulerUtilsTestCase, self).setUp()
-        self.scheduler_client = mock.MagicMock()
-        self.rpc_client_class = mock.MagicMock()
-        self.service = mock.MagicMock()
-        self.ctxt = mock.MagicMock()
-
-    def test_get_rpc_client_for_service(self):
-        with mock.patch.dict(
-            scheduler_utils.RPC_TOPIC_TO_CLIENT_CLASS_MAP,
-            {constants.WORKER_MAIN_MESSAGING_TOPIC: self.rpc_client_class},
-            clear=True
-        ):
-            self.service.topic = constants.WORKER_MAIN_MESSAGING_TOPIC
-            self.service.host = 'test_host'
-
-            result = scheduler_utils.get_rpc_client_for_service(self.service)
-
-            self.rpc_client_class.assert_called_once_with(
-                topic='coriolis_worker.test_host')
-
-            self.assertEqual(result, self.rpc_client_class.return_value)
-
-    def test_get_rpc_client_for_service_different_topic(self):
-        with mock.patch.dict(
-            scheduler_utils.RPC_TOPIC_TO_CLIENT_CLASS_MAP,
-            {mock.sentinel.topic: self.rpc_client_class},
-            clear=True
-        ):
-            self.service.topic = mock.sentinel.topic
-            self.service.host = 'host'
-
-            result = scheduler_utils.get_rpc_client_for_service(self.service)
-
-            self.rpc_client_class.assert_called_once_with(
-                topic=mock.sentinel.topic)
-
-            self.assertEqual(result, self.rpc_client_class.return_value)
-
-    def test_get_rpc_client_for_service_with_exception(self):
-        self.service.topic = 'non-existent-topic'
-        self.service.host = 'host'
-
-        self.assertRaises(exception.NotFound,
-                          scheduler_utils.get_rpc_client_for_service,
-                          self.service)
-
-    def test_get_any_worker_service_no_services(self):
-        self.scheduler_client.get_workers_for_specs.return_value = []
-
-        self.assertRaises(exception.NoWorkerServiceError,
-                          scheduler_utils.get_any_worker_service,
-                          self.scheduler_client, self.ctxt)
-
-    @mock.patch('coriolis.scheduler.scheduler_utils.db_api.get_service')
-    @mock.patch('random.choice')
-    def test_get_any_worker_service_random_choice(self, mock_random_choice,
-                                                  get_service_mock):
-        service_mock1 = {'id': 'test_id1'}
-        service_mock2 = {'id': 'test_id2'}
-
-        self.scheduler_client.get_workers_for_specs.return_value = [
-            service_mock1, service_mock2]
-
-        get_service_mock.return_value = [service_mock1, service_mock2]
-        mock_random_choice.return_value = service_mock1
-
-        result = scheduler_utils.get_any_worker_service(
-            self.scheduler_client, self.ctxt, random_choice=True)
-
-        mock_random_choice.assert_called_once_with([
-            service_mock1, service_mock2])
-        get_service_mock.assert_called_once_with(
-            self.ctxt, service_mock1['id'])
-        self.assertEqual(result, get_service_mock.return_value)
-
-    @mock.patch('coriolis.scheduler.scheduler_utils.db_api.get_service')
-    def test_get_any_worker_service_raw_dict(self, get_service_mock):
-        service_mock = {'id': 'test_id'}
-
-        self.scheduler_client.get_workers_for_specs.return_value = [
-            service_mock]
-
-        result = scheduler_utils.get_any_worker_service(
-            self.scheduler_client, self.ctxt, raw_dict=True)
-
-        get_service_mock.assert_not_called()
-        self.assertEqual(result, service_mock)
-
-    def test_get_worker_rpc_for_host(self):
-        with mock.patch.dict(
-            scheduler_utils.RPC_TOPIC_TO_CLIENT_CLASS_MAP,
-            {constants.WORKER_MAIN_MESSAGING_TOPIC: self.rpc_client_class},
-            clear=True
-        ):
-            host = 'test_host'
-            client_args = ('arg1', 'arg2')
-            client_kwargs = {'key1': 'value1', 'key2': 'value2'}
-
-            result = scheduler_utils.get_worker_rpc_for_host(
-                host, *client_args, **client_kwargs)
-
-            self.rpc_client_class.assert_called_once_with(
-                *client_args, topic='coriolis_worker.test_host',
-                **client_kwargs)
-
-            self.assertEqual(result, self.rpc_client_class.return_value)

coriolis/tests/taskflow/test_base.py

@@ -113,95 +113,6 @@ class BaseRunWorkerTaskTestCase(test_base.CoriolisBaseTestCase):
                 self.task._scheduler_client, mock_scheduler_client)
             mock_SchedulerClient.assert_not_called()
 
-    def test_set_provides_for_dependencies(self):
-        self.task._set_provides_for_dependencies(self.kwargs)
-        self.assertEqual(self.kwargs,
-                         {'test_task_id': 'test_task_id',
-                          'provides': ['task-test_task-result']})
-
-    def test_set_provides_for_dependencies_with_provides_key(self):
-        kwargs = {'provides': ['test']}
-        self.task._set_provides_for_dependencies(kwargs)
-        self.assertEqual(kwargs, {'provides':
-                                  ['test', 'task-test_task-result']})
-
-    def test_set_requires_for_dependencies(self):
-        self.task._set_requires_for_dependencies(self.kwargs, self.depends_on)
-        self.assertEqual(self.kwargs,
-                         {'test_task_id': 'test_task_id',
-                          'requires': ['task-test_task_id-result']})
-
-    def test_set_requires_for_dependencies_with_requires_key(self):
-        kwargs = {'requires': ['test']}
-        self.task._set_requires_for_dependencies(kwargs, self.depends_on)
-        self.assertEqual(kwargs,
-                         {'requires': ['test', 'task-test_task_id-result']})
-
-    @mock.patch('coriolis.tasks.factory.get_task_runner_class')
-    def test_set_requires_for_task_info_fields(self, mock_get_task_runner):
-        self.mock_task_runner.get_required_task_info_properties.\
-            return_value = ['prop1']
-        mock_get_task_runner.return_value = self.mock_task_runner
-        kwargs = {'requires': ['test']}
-
-        self.task._set_requires_for_task_info_fields(kwargs)
-        self.assertEqual(kwargs, {'requires': ['test', 'prop1']})
-
-    @mock.patch('coriolis.tasks.factory.get_task_runner_class')
-    def test_set_requires_for_task_info_fields_with_cleanup(
-            self, mock_get_task_runner):
-        self.mock_task_runner.get_required_task_info_properties.\
-            return_value = ['main_task_dep1', 'main_task_dep2']
-        self.mock_task_runner.get_returned_task_info_properties.\
-            return_value = ['main_task_dep1']
-
-        self.mock_cleanup_task_runner.get_required_task_info_properties.\
-            return_value = ['cleanup_task_dep1', 'cleanup_task_dep2']
-
-        mock_get_task_runner.side_effect = [self.mock_task_runner,
-                                            self.mock_cleanup_task_runner]
-
-        self.task._cleanup_task_runner_type = 'cleanup_runner_type'
-        kwargs = {'requires': ['test']}
-
-        self.task._set_requires_for_task_info_fields(kwargs)
-        self.assertEqual(sorted(kwargs['requires']),
-                         sorted(['test', 'main_task_dep1', 'main_task_dep2',
-                                 'cleanup_task_dep1', 'cleanup_task_dep2']))
-
-    @mock.patch('coriolis.tasks.factory.get_task_runner_class')
-    def test_set_provides_for_task_info_fields(self, mock_get_task_runner):
-        self.mock_task_runner.get_returned_task_info_properties.\
-            return_value = ['prop1']
-        mock_get_task_runner.return_value = self.mock_task_runner
-        kwargs = {'provides': ['test']}
-
-        self.task._set_provides_for_task_info_fields(kwargs)
-        self.assertEqual(kwargs, {'provides': ['test', 'prop1']})
-
-    @mock.patch('coriolis.tasks.factory.get_task_runner_class')
-    def test_set_provides_for_task_info_fields_with_cleanup(
-            self, mock_get_task_runner):
-        self.mock_task_runner.get_returned_task_info_properties.\
-            return_value = ['main_task_dep1', 'main_task_dep2']
-        self.mock_task_runner.get_required_task_info_properties.\
-            return_value = ['main_task_dep1']
-
-        self.mock_cleanup_task_runner.get_returned_task_info_properties.\
-            return_value = ['cleanup_task_dep1', 'cleanup_task_dep2']
-
-        mock_get_task_runner.side_effect = [self.mock_task_runner,
-                                            self.mock_cleanup_task_runner]
-
-        self.task._cleanup_task_runner_type = 'cleanup_runner_type'
-        kwargs = {'provides': ['test']}
-
-        self.task._set_provides_for_task_info_fields(kwargs)
-
-        self.assertEqual(sorted(kwargs['provides']),
-                         sorted(['test', 'main_task_dep1', 'main_task_dep2',
-                                 'cleanup_task_dep1', 'cleanup_task_dep2']))
-
     @mock.patch.object(rpc_client.WorkerClient, 'from_service_definition')
     @mock.patch.object(SchedulerClient, 'get_worker_service_for_task')
     def test_get_worker_service_rpc_for_task(self, mock_get_worker_service,

coriolis/tests/worker/rpc/test_server.py

@@ -2,9 +2,7 @@
 # All Rights Reserved.
 import multiprocessing
 import os
-import shutil
 import signal
-import tempfile
 from unittest import mock
 
 import ddt
@@ -96,20 +94,6 @@ class WorkerServerEndpointTestCase(test_base.CoriolisBaseTestCase):
         self.assertEqual(result, mock_check_create_service.return_value)
         self.assertEqual(result, self.server._service_registration)
 
-    def test__check_remove_dir(self):
-        tmp = tempfile.mkdtemp()
-        self.server._check_remove_dir(tmp)
-        self.assertFalse(os.path.exists(tmp))
-
-    @mock.patch.object(shutil, 'rmtree')
-    def test__check_remove_dir_fails(self, mock_rmtree):
-        tmp = tempfile.mkdtemp()
-        mock_rmtree.side_effect = Exception('YOLO')
-        with self.assertLogs('coriolis.worker.rpc.server',
-                             level=logging.ERROR):
-            self.server._check_remove_dir(tmp)
-        os.rmdir(tmp)
-
     @mock.patch.object(server.WorkerServerEndpoint, 'get_available_providers')
     @mock.patch.object(server.WorkerServerEndpoint, 'get_diagnostics')
     def test_get_service_status(self, mock_get_diagnostics,

coriolis/worker/rpc/server.py

@@ -4,7 +4,6 @@
 from logging import handlers
 import multiprocessing
 import os
-import shutil
 import signal
 import sys
 import threading
@@ -87,14 +86,6 @@ class WorkerServerEndpoint(object):
         self._service_registration = service_registration
         return service_registration
 
-    def _check_remove_dir(self, path):
-        try:
-            if os.path.exists(path):
-                shutil.rmtree(path)
-        except Exception as ex:
-            # Ignore the exception
-            LOG.exception(ex)
-
     def get_service_status(self, ctxt):
         diagnostics = self.get_diagnostics(ctxt)
         status = {