Remove unused scheduler functions

* get_service_capabilities
* get_host_list
* host_service_caps_stale
* delete_expired_host_services

The functions were introduced in d328ddcadb24d1b1961bd05a7676bc8f54b6776f
but are currently unused outside of nova.tests

Change-Id: I15388db5eb684a9f5cfe74f4c2a32b6c87f57894

8 files changed, 0 insertions, 254 deletions

diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py
index c75a5014c..324b89edb 100644
--- a/nova/scheduler/driver.py
+++ b/nova/scheduler/driver.py
@@ -143,15 +143,6 @@ class Scheduler(object):
         self.compute_api = compute_api.API()
         self.compute_rpcapi = compute_rpcapi.ComputeAPI()
 
-    def get_host_list(self):
-        """Get a list of hosts from the HostManager."""
-        return self.host_manager.get_host_list()
-
-    def get_service_capabilities(self):
-        """Get the normalized set of capabilities for the services.
-        """
-        return self.host_manager.get_service_capabilities()
-
     def update_service_capabilities(self, service_name, host, capabilities):
         """Process a capability update from a service node."""
         self.host_manager.update_service_capabilities(service_name,
diff --git a/nova/scheduler/host_manager.py b/nova/scheduler/host_manager.py
index dd705a552..91593b67b 100644
--- a/nova/scheduler/host_manager.py
+++ b/nova/scheduler/host_manager.py
@@ -223,53 +223,6 @@ class HostManager(object):
                 filtered_hosts.append(host)
         return filtered_hosts
 
-    def get_host_list(self):
-        """Returns a list of dicts for each host that the Zone Manager
-        knows about. Each dict contains the host_name and the service
-        for that host.
-        """
-        ret = []
-        for host in self.service_states:
-            for svc in self.service_states[host]:
-                ret.append({"service": svc, "host_name": host})
-        return ret
-
-    def get_service_capabilities(self):
-        """Roll up all the individual host info to generic 'service'
-           capabilities. Each capability is aggregated into
-           <cap>_min and <cap>_max values."""
-        hosts_dict = self.service_states
-
-        # TODO(sandy) - be smarter about fabricating this structure.
-        # But it's likely to change once we understand what the Best-Match
-        # code will need better.
-        combined = {}  # { <service>_<cap> : (min, max), ... }
-        stale_host_services = {}  # { host1 : [svc1, svc2], host2 :[svc1]}
-        for host, host_dict in hosts_dict.iteritems():
-            for service_name, service_dict in host_dict.iteritems():
-                if not service_dict.get("enabled", True):
-                    # Service is disabled; do no include it
-                    continue
-
-                # Check if the service capabilities became stale
-                if self.host_service_caps_stale(host, service_name):
-                    if host not in stale_host_services:
-                        stale_host_services[host] = []  # Adding host key once
-                    stale_host_services[host].append(service_name)
-                    continue
-                for cap, value in service_dict.iteritems():
-                    if cap == "timestamp":  # Timestamp is not needed
-                        continue
-                    key = "%s_%s" % (service_name, cap)
-                    min_value, max_value = combined.get(key, (value, value))
-                    min_value = min(min_value, value)
-                    max_value = max(max_value, value)
-                    combined[key] = (min_value, max_value)
-
-        # Delete the expired host services
-        self.delete_expired_host_services(stale_host_services)
-        return combined
-
     def update_service_capabilities(self, service_name, host, capabilities):
         """Update the per-service capabilities based on this notification."""
         LOG.debug(_("Received %(service_name)s service update from "
@@ -281,24 +234,6 @@ class HostManager(object):
         service_caps[service_name] = capab_copy
         self.service_states[host] = service_caps
 
-    def host_service_caps_stale(self, host, service):
-        """Check if host service capabilites are not recent enough."""
-        allowed_time_diff = FLAGS.periodic_interval * 3
-        caps = self.service_states[host][service]
-        if ((timeutils.utcnow() - caps["timestamp"]) <=
-            datetime.timedelta(seconds=allowed_time_diff)):
-            return False
-        return True
-
-    def delete_expired_host_services(self, host_services_dict):
-        """Delete all the inactive host services information."""
-        for host, services in host_services_dict.iteritems():
-            service_caps = self.service_states[host]
-            for service in services:
-                del service_caps[service]
-                if len(service_caps) == 0:  # Delete host if no services
-                    del self.service_states[host]
-
     def get_all_host_states(self, context, topic):
         """Returns a dict of all the hosts the HostManager
         knows about. Also, each of the consumable resources in HostState
diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py
index b0ab8bc38..2a096cce8 100644
--- a/nova/scheduler/manager.py
+++ b/nova/scheduler/manager.py
@@ -67,14 +67,6 @@ class SchedulerManager(manager.Manager):
         # the rpc API as well, and the version should be updated accordingly.
         return functools.partial(self._schedule, key)
 
-    def get_host_list(self, context):
-        """Get a list of hosts from the HostManager."""
-        return self.driver.get_host_list()
-
-    def get_service_capabilities(self, context):
-        """Get the normalized set of capabilities for this zone."""
-        return self.driver.get_service_capabilities()
-
     def update_service_capabilities(self, context, service_name=None,
             host=None, capabilities=None, **kwargs):
         """Process a capability update from a service node."""
diff --git a/nova/scheduler/rpcapi.py b/nova/scheduler/rpcapi.py
index cdd3e6480..b2522ab53 100644
--- a/nova/scheduler/rpcapi.py
+++ b/nova/scheduler/rpcapi.py
@@ -75,6 +75,3 @@ class SchedulerAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         self.fanout_cast(ctxt, self.make_msg('update_service_capabilities',
                 service_name=service_name, host=host,
                 capabilities=capabilities))
-
-    def get_host_list(self, ctxt):
-        return self.call(ctxt, self.make_msg('get_host_list'))
diff --git a/nova/tests/scheduler/fakes.py b/nova/tests/scheduler/fakes.py
index 29d4807ac..84424c1c7 100644
--- a/nova/tests/scheduler/fakes.py
+++ b/nova/tests/scheduler/fakes.py
@@ -86,14 +86,6 @@ class FakeHostManager(host_manager.HostManager):
             },
         }
 
-    def get_host_list_from_db(self, context):
-        return [
-            ('host1', dict(free_disk_gb=1024, free_ram_mb=1024)),
-            ('host2', dict(free_disk_gb=2048, free_ram_mb=2048)),
-            ('host3', dict(free_disk_gb=4096, free_ram_mb=4096)),
-            ('host4', dict(free_disk_gb=8192, free_ram_mb=8192)),
-        ]
-
 
 class FakeHostState(host_manager.HostState):
     def __init__(self, host, topic, attribute_dict):
diff --git a/nova/tests/scheduler/test_host_manager.py b/nova/tests/scheduler/test_host_manager.py
index d28e51c00..01521c65d 100644
--- a/nova/tests/scheduler/test_host_manager.py
+++ b/nova/tests/scheduler/test_host_manager.py
@@ -122,120 +122,6 @@ class HostManagerTestCase(test.TestCase):
                     'host2': {'compute': host2_compute_capabs}}
         self.assertDictMatch(service_states, expected)
 
-    def test_host_service_caps_stale(self):
-        self.flags(periodic_interval=5)
-
-        host1_compute_capabs = dict(free_memory=1234, host_memory=5678,
-                timestamp=datetime.datetime.fromtimestamp(3000))
-        host1_volume_capabs = dict(free_disk=4321,
-                timestamp=datetime.datetime.fromtimestamp(3005))
-        host2_compute_capabs = dict(free_memory=8756,
-                timestamp=datetime.datetime.fromtimestamp(3010))
-
-        service_states = {'host1': {'compute': host1_compute_capabs,
-                                    'volume': host1_volume_capabs},
-                          'host2': {'compute': host2_compute_capabs}}
-
-        self.host_manager.service_states = service_states
-
-        self.mox.StubOutWithMock(timeutils, 'utcnow')
-        timeutils.utcnow().AndReturn(datetime.datetime.fromtimestamp(3020))
-        timeutils.utcnow().AndReturn(datetime.datetime.fromtimestamp(3020))
-        timeutils.utcnow().AndReturn(datetime.datetime.fromtimestamp(3020))
-
-        self.mox.ReplayAll()
-        res1 = self.host_manager.host_service_caps_stale('host1', 'compute')
-        res2 = self.host_manager.host_service_caps_stale('host1', 'volume')
-        res3 = self.host_manager.host_service_caps_stale('host2', 'compute')
-
-        self.assertEqual(res1, True)
-        self.assertEqual(res2, False)
-        self.assertEqual(res3, False)
-
-    def test_delete_expired_host_services(self):
-        host1_compute_capabs = dict(free_memory=1234, host_memory=5678,
-                timestamp=datetime.datetime.fromtimestamp(3000))
-        host1_volume_capabs = dict(free_disk=4321,
-                timestamp=datetime.datetime.fromtimestamp(3005))
-        host2_compute_capabs = dict(free_memory=8756,
-                timestamp=datetime.datetime.fromtimestamp(3010))
-
-        service_states = {'host1': {'compute': host1_compute_capabs,
-                                    'volume': host1_volume_capabs},
-                          'host2': {'compute': host2_compute_capabs}}
-        self.host_manager.service_states = service_states
-
-        to_delete = {'host1': {'volume': host1_volume_capabs},
-                     'host2': {'compute': host2_compute_capabs}}
-
-        self.host_manager.delete_expired_host_services(to_delete)
-        # Make sure dictionary isn't re-assigned
-        self.assertEqual(self.host_manager.service_states, service_states)
-
-        expected = {'host1': {'compute': host1_compute_capabs}}
-        self.assertEqual(service_states, expected)
-
-    def test_get_service_capabilities(self):
-        host1_compute_capabs = dict(free_memory=1000, host_memory=5678,
-                timestamp=datetime.datetime.fromtimestamp(3000))
-        host1_volume_capabs = dict(free_disk=4321,
-                timestamp=datetime.datetime.fromtimestamp(3005))
-        host2_compute_capabs = dict(free_memory=8756,
-                timestamp=datetime.datetime.fromtimestamp(3010))
-        host2_volume_capabs = dict(free_disk=8756,
-                enabled=False,
-                timestamp=datetime.datetime.fromtimestamp(3010))
-        host3_compute_capabs = dict(free_memory=1234, host_memory=4000,
-                timestamp=datetime.datetime.fromtimestamp(3010))
-        host3_volume_capabs = dict(free_disk=2000,
-                timestamp=datetime.datetime.fromtimestamp(3010))
-
-        service_states = {'host1': {'compute': host1_compute_capabs,
-                                    'volume': host1_volume_capabs},
-                          'host2': {'compute': host2_compute_capabs,
-                                    'volume': host2_volume_capabs},
-                          'host3': {'compute': host3_compute_capabs,
-                                    'volume': host3_volume_capabs}}
-        self.host_manager.service_states = service_states
-
-        info = {'called': 0}
-
-        # This tests with 1 volume disabled (host2), and 1 volume node
-        # as stale (host1)
-        def _fake_host_service_caps_stale(host, service):
-            info['called'] += 1
-            if host == 'host1':
-                if service == 'compute':
-                    return False
-                elif service == 'volume':
-                    return True
-            elif host == 'host2':
-                # Shouldn't get here for 'volume' because the service
-                # is disabled
-                self.assertEqual(service, 'compute')
-                return False
-            self.assertEqual(host, 'host3')
-            return False
-
-        self.stubs.Set(self.host_manager, 'host_service_caps_stale',
-                _fake_host_service_caps_stale)
-
-        self.mox.StubOutWithMock(self.host_manager,
-                'delete_expired_host_services')
-        self.host_manager.delete_expired_host_services({'host1': ['volume']})
-
-        self.mox.ReplayAll()
-        result = self.host_manager.get_service_capabilities()
-
-        self.assertEqual(info['called'], 5)
-
-        # only 1 volume node active == 'host3', so min/max is 2000
-        expected = {'volume_free_disk': (2000, 2000),
-                    'compute_host_memory': (4000, 5678),
-                    'compute_free_memory': (1000, 8756)}
-
-        self.assertDictMatch(result, expected)
-
     def test_get_all_host_states(self):
         self.flags(reserved_host_memory_mb=512,
                 reserved_host_disk_mb=1024)
diff --git a/nova/tests/scheduler/test_rpcapi.py b/nova/tests/scheduler/test_rpcapi.py
index cfd16a08b..000138bc9 100644
--- a/nova/tests/scheduler/test_rpcapi.py
+++ b/nova/tests/scheduler/test_rpcapi.py
@@ -100,6 +100,3 @@ class SchedulerRpcAPITestCase(test.TestCase):
         self._test_scheduler_api('update_service_capabilities',
                 rpc_method='fanout_cast', service_name='fake_name',
                 host='fake_host', capabilities='fake_capabilities')
-
-    def test_get_host_list(self):
-        self._test_scheduler_api('get_host_list', rpc_method='call')
diff --git a/nova/tests/scheduler/test_scheduler.py b/nova/tests/scheduler/test_scheduler.py
index 38bdeeb40..7399d38d9 100644
--- a/nova/tests/scheduler/test_scheduler.py
+++ b/nova/tests/scheduler/test_scheduler.py
@@ -67,28 +67,6 @@ class SchedulerManagerTestCase(test.TestCase):
         manager = self.manager
         self.assertTrue(isinstance(manager.driver, self.driver_cls))
 
-    def test_get_host_list(self):
-        expected = 'fake_hosts'
-
-        self.mox.StubOutWithMock(self.manager.driver, 'get_host_list')
-        self.manager.driver.get_host_list().AndReturn(expected)
-
-        self.mox.ReplayAll()
-        result = self.manager.get_host_list(self.context)
-        self.assertEqual(result, expected)
-
-    def test_get_service_capabilities(self):
-        expected = 'fake_service_capabs'
-
-        self.mox.StubOutWithMock(self.manager.driver,
-                'get_service_capabilities')
-        self.manager.driver.get_service_capabilities().AndReturn(
-                expected)
-
-        self.mox.ReplayAll()
-        result = self.manager.get_service_capabilities(self.context)
-        self.assertEqual(result, expected)
-
     def test_update_service_capabilities(self):
         service_name = 'fake_service'
         host = 'fake_host'
@@ -325,28 +303,6 @@ class SchedulerTestCase(test.TestCase):
         self.context = context.RequestContext('fake_user', 'fake_project')
         self.topic = 'fake_topic'
 
-    def test_get_host_list(self):
-        expected = 'fake_hosts'
-
-        self.mox.StubOutWithMock(self.driver.host_manager, 'get_host_list')
-        self.driver.host_manager.get_host_list().AndReturn(expected)
-
-        self.mox.ReplayAll()
-        result = self.driver.get_host_list()
-        self.assertEqual(result, expected)
-
-    def test_get_service_capabilities(self):
-        expected = 'fake_service_capabs'
-
-        self.mox.StubOutWithMock(self.driver.host_manager,
-                'get_service_capabilities')
-        self.driver.host_manager.get_service_capabilities().AndReturn(
-                expected)
-
-        self.mox.ReplayAll()
-        result = self.driver.get_service_capabilities()
-        self.assertEqual(result, expected)
-
     def test_update_service_capabilities(self):
         service_name = 'fake_service'
         host = 'fake_host'