text: # Copyright (c) 2011 OpenStack Foundation
  # All Rights Reserved.
  #
  #    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.
  """Tests For HostManager."""
  
  from datetime import datetime
  from datetime import timedelta
  from unittest import mock
  
  import ddt
  from oslo_config import cfg
  from oslo_serialization import jsonutils
  from oslo_utils import timeutils
  
  from cinder.common import constants
  from cinder import context
  from cinder import db
  from cinder import exception
  from cinder import objects
  from cinder.scheduler import filters
  from cinder.scheduler import host_manager
  from cinder import test
  from cinder.tests.unit import fake_constants as fake
  from cinder.tests.unit.objects import test_service
  
  CONF = cfg.CONF
  
  
  class FakeFilterClass1(filters.BaseBackendFilter):
      def backend_passes(self, host_state, filter_properties):
          pass
  
  
  class FakeFilterClass2(filters.BaseBackendFilter):
      def backend_passes(self, host_state, filter_properties):
          pass
  
  
  class FakeFilterClass3(filters.BaseHostFilter):
      def host_passes(self, host_state, filter_properties):
          return host_state.get('volume_backend_name') == \
              filter_properties.get('volume_type')['volume_backend_name']
  
  
  @ddt.ddt
  class HostManagerTestCase(test.TestCase):
      """Test case for HostManager class."""
  
      def setUp(self):
          super(HostManagerTestCase, self).setUp()
          self.host_manager = host_manager.HostManager()
          self.fake_backends = [host_manager.BackendState('fake_be%s' % x, None)
                                for x in range(1, 5)]
          # For a second scheduler service.
          self.host_manager_1 = host_manager.HostManager()
  
      @mock.patch(
          'cinder.scheduler.filters.BackendFilterHandler.get_all_classes')
      def test_initialzie_with_default_filters(self, mock_get_all_classes):
          self.flags(scheduler_default_filters=
                     'FakeFilterClass1,FakeFilterClass2')
          mock_get_all_classes.return_value = [
              FakeFilterClass1, FakeFilterClass2, FakeFilterClass3]
          h_manager = host_manager.HostManager()
          self.assertListEqual([FakeFilterClass1, FakeFilterClass2],
                               h_manager.enabled_filters)
  
      def test_choose_backend_filters_not_found(self):
          self.host_manager.filter_classes = [FakeFilterClass1,
                                              FakeFilterClass2]
          self.assertRaises(exception.SchedulerHostFilterNotFound,
                            self.host_manager._choose_backend_filters,
                            'FakeFilterClass3')
  
      def test_choose_backend_filters(self):
          self.host_manager.filter_classes = [FakeFilterClass1,
                                              FakeFilterClass2]
  
          # Test 'volume' returns 1 correct function
          filter_classes = self.host_manager._choose_backend_filters(
              'FakeFilterClass2')
          self.assertEqual(1, len(filter_classes))
          self.assertEqual('FakeFilterClass2', filter_classes[0].__name__)
  
      @mock.patch('cinder.scheduler.host_manager.HostManager.'
                  '_choose_backend_filters')
      def test_get_filtered_backends(self, _mock_choose_backend_filters):
          filter_class = FakeFilterClass1
          mock_func = mock.Mock()
          mock_func.return_value = True
          filter_class._filter_one = mock_func
          _mock_choose_backend_filters.return_value = [filter_class]
  
          fake_properties = {'moo': 1, 'cow': 2}
          expected = []
          for fake_backend in self.fake_backends:
              expected.append(mock.call(fake_backend, fake_properties))
          host_manager1 = host_manager.HostManager()
          result = host_manager1.get_filtered_backends(self.fake_backends,
                                                       fake_properties)
          self.assertEqual(expected, mock_func.call_args_list)
          self.assertEqual(set(self.fake_backends), set(result))
  
      @mock.patch(
          'cinder.scheduler.host_manager.HostManager._is_just_initialized')
      @mock.patch('cinder.scheduler.host_manager.HostManager._get_updated_pools')
      @mock.patch('oslo_utils.timeutils.utcnow')
      def test_update_service_capabilities(self, _mock_utcnow,
                                           _mock_get_updated_pools,
                                           _mock_is_just_initialized):
          service_states = self.host_manager.service_states
          self.assertDictEqual({}, service_states)
          _mock_is_just_initialized.return_value = False
          _mock_utcnow.side_effect = [31338, 31339]
  
          _mock_get_updated_pools.return_value = []
          timestamp = jsonutils.to_primitive(datetime.utcnow())
          host1_volume_capabs = dict(free_capacity_gb=4321, timestamp=timestamp)
          host1_old_volume_capabs = dict(free_capacity_gb=1, timestamp=timestamp)
          host2_volume_capabs = dict(free_capacity_gb=5432)
          host3_volume_capabs = dict(free_capacity_gb=6543)
  
          service_name = 'volume'
          # The host manager receives a deserialized timestamp
          timestamp = datetime.strptime(timestamp, timeutils.PERFECT_TIME_FORMAT)
          self.host_manager.update_service_capabilities(service_name, 'host1',
                                                        host1_volume_capabs,
                                                        None, timestamp)
          # It'll ignore older updates
          old_timestamp = timestamp - timedelta(hours=1)
          self.host_manager.update_service_capabilities(service_name, 'host1',
                                                        host1_old_volume_capabs,
                                                        None, old_timestamp)
          self.host_manager.update_service_capabilities(service_name, 'host2',
                                                        host2_volume_capabs,
                                                        None, None)
          self.host_manager.update_service_capabilities(service_name, 'host3',
                                                        host3_volume_capabs,
                                                        None, None)
  
          # Make sure dictionary isn't re-assigned
          self.assertEqual(service_states, self.host_manager.service_states)
  
          host1_volume_capabs['timestamp'] = timestamp
          host2_volume_capabs['timestamp'] = 31338
          host3_volume_capabs['timestamp'] = 31339
  
          expected = {'host1': host1_volume_capabs,
                      'host2': host2_volume_capabs,
                      'host3': host3_volume_capabs}
          self.assertDictEqual(expected, service_states)
  
      @mock.patch(
          'cinder.scheduler.host_manager.HostManager._is_just_initialized')
      @mock.patch(
          'cinder.scheduler.host_manager.HostManager.get_usage_and_notify')
      @mock.patch('oslo_utils.timeutils.utcnow')
      def test_update_and_notify_service_capabilities_case1(
              self, _mock_utcnow,
              _mock_get_usage_and_notify,
              _mock_is_just_initialized):
  
          _mock_utcnow.side_effect = [31337, 31338, 31339]
          _mock_is_just_initialized.return_value = False
          service_name = 'volume'
  
          capab1 = {'pools': [{
                    'pool_name': 'pool1', 'thick_provisioning_support': True,
                    'thin_provisioning_support': False, 'total_capacity_gb': 10,
                    'free_capacity_gb': 10, 'max_over_subscription_ratio': '1',
                    'provisioned_capacity_gb': 0, 'allocated_capacity_gb': 0,
                    'reserved_percentage': 0}]}
  
          # Run 1:
          # capa: capa1
          # S0: update_service_capabilities()
          # S0: notify_service_capabilities()
          # S1: update_service_capabilities()
          #
          # notify capab1 to ceilometer by S0
          #
  
          # S0: update_service_capabilities()
          self.host_manager.update_service_capabilities(service_name, 'host1',
                                                        capab1, None, None)
          self.assertDictEqual(dict(dict(timestamp=31337), **capab1),
                               self.host_manager.service_states['host1'])
  
          # S0: notify_service_capabilities()
          self.host_manager.notify_service_capabilities(service_name, 'host1',
                                                        capab1, None)
          self.assertDictEqual(dict(dict(timestamp=31337), **capab1),
                               self.host_manager.service_states['host1'])
          self.assertDictEqual(
              dict(dict(timestamp=31338), **capab1),
              self.host_manager.service_states_last_update['host1'])
  
          # notify capab1 to ceilometer by S0
          self.assertEqual(1, _mock_get_usage_and_notify.call_count)
  
          # S1: update_service_capabilities()
          self.host_manager_1.update_service_capabilities(service_name, 'host1',
                                                          capab1, None, None)
  
          self.assertDictEqual(dict(dict(timestamp=31339), **capab1),
                               self.host_manager_1.service_states['host1'])
  
      @mock.patch(
          'cinder.scheduler.host_manager.HostManager._is_just_initialized')
      @mock.patch(
          'cinder.scheduler.host_manager.HostManager.get_usage_and_notify')
      @mock.patch('oslo_utils.timeutils.utcnow')
      def test_update_and_notify_service_capabilities_case2(
              self, _mock_utcnow,
              _mock_get_usage_and_notify,
              _mock_is_just_initialized):
  
          _mock_utcnow.side_effect = [31340, 31341, 31342]
          _mock_is_just_initialized.return_value = False
  
          service_name = 'volume'
  
          capab1 = {'pools': [{
                    'pool_name': 'pool1', 'thick_provisioning_support': True,
                    'thin_provisioning_support': False, 'total_capacity_gb': 10,
                    'free_capacity_gb': 10, 'max_over_subscription_ratio': '1',
                    'provisioned_capacity_gb': 0, 'allocated_capacity_gb': 0,
                    'reserved_percentage': 0}]}
  
          self.host_manager.service_states['host1'] = (
              dict(dict(timestamp=31337), **capab1))
          self.host_manager.service_states_last_update['host1'] = (
              dict(dict(timestamp=31338), **capab1))
          self.host_manager_1.service_states['host1'] = (
              dict(dict(timestamp=31339), **capab1))
  
          # Run 2:
          # capa: capa1
          # S0: update_service_capabilities()
          # S1: update_service_capabilities()
          # S1: notify_service_capabilities()
          #
          # Don't notify capab1 to ceilometer.
  
          # S0: update_service_capabilities()
          self.host_manager.update_service_capabilities(service_name, 'host1',
                                                        capab1, None, None)
  
          self.assertDictEqual(dict(dict(timestamp=31340), **capab1),
                               self.host_manager.service_states['host1'])
  
          self.assertDictEqual(
              dict(dict(timestamp=31338), **capab1),
              self.host_manager.service_states_last_update['host1'])
  
          # S1: update_service_capabilities()
          self.host_manager_1.update_service_capabilities(service_name, 'host1',
                                                          capab1, None, None)
  
          self.assertDictEqual(dict(dict(timestamp=31341), **capab1),
                               self.host_manager_1.service_states['host1'])
  
          self.assertDictEqual(
              dict(dict(timestamp=31339), **capab1),
              self.host_manager_1.service_states_last_update['host1'])
  
          # S1: notify_service_capabilities()
          self.host_manager_1.notify_service_capabilities(service_name, 'host1',
                                                          capab1, None)
  
          self.assertDictEqual(dict(dict(timestamp=31341), **capab1),
                               self.host_manager_1.service_states['host1'])
  
          self.assertDictEqual(
              self.host_manager_1.service_states_last_update['host1'],
              dict(dict(timestamp=31339), **capab1))
  
          # Don't notify capab1 to ceilometer.
          self.assertEqual(0, _mock_get_usage_and_notify.call_count)
  
      @mock.patch(
          'cinder.scheduler.host_manager.HostManager.get_usage_and_notify')
      @mock.patch('oslo_utils.timeutils.utcnow')
      def test_update_and_notify_service_capabilities_case3(
              self, _mock_utcnow,
              _mock_get_usage_and_notify):
  
          _mock_utcnow.side_effect = [31343, 31344, 31345]
  
          service_name = 'volume'
  
          capab1 = {'pools': [{
                    'pool_name': 'pool1', 'thick_provisioning_support': True,
                    'thin_provisioning_support': False, 'total_capacity_gb': 10,
                    'free_capacity_gb': 10, 'max_over_subscription_ratio': '1',
                    'provisioned_capacity_gb': 0, 'allocated_capacity_gb': 0,
                    'reserved_percentage': 0}]}
  
          self.host_manager.service_states['host1'] = (
              dict(dict(timestamp=31340), **capab1))
          self.host_manager.service_states_last_update['host1'] = (
              dict(dict(timestamp=31338), **capab1))
          self.host_manager_1.service_states['host1'] = (
              dict(dict(timestamp=31341), **capab1))
          self.host_manager_1.service_states_last_update['host1'] = (
              dict(dict(timestamp=31339), **capab1))
  
          # Run 3:
          # capa: capab1
          # S0: notify_service_capabilities()
          # S0: update_service_capabilities()
          # S1: update_service_capabilities()
          #
          # Don't notify capab1 to ceilometer.
  
          # S0: notify_service_capabilities()
          self.host_manager.notify_service_capabilities(service_name, 'host1',
                                                        capab1, None)
          self.assertDictEqual(
              dict(dict(timestamp=31338), **capab1),
              self.host_manager.service_states_last_update['host1'])
  
          self.assertDictEqual(dict(dict(timestamp=31340), **capab1),
                               self.host_manager.service_states['host1'])
  
          # Don't notify capab1 to ceilometer.
          self.assertEqual(0, _mock_get_usage_and_notify.call_count)
  
          # S0: update_service_capabilities()
          self.host_manager.update_service_capabilities(service_name, 'host1',
                                                        capab1, None, None)
  
          self.assertDictEqual(
              dict(dict(timestamp=31340), **capab1),
              self.host_manager.service_states_last_update['host1'])
  
          self.assertDictEqual(dict(dict(timestamp=31344), **capab1),
                               self.host_manager.service_states['host1'])
  
          # S1: update_service_capabilities()
          self.host_manager_1.update_service_capabilities(service_name, 'host1',
                                                          capab1, None, None)
          self.assertDictEqual(dict(dict(timestamp=31345), **capab1),
                               self.host_manager_1.service_states['host1'])
  
          self.assertDictEqual(
              dict(dict(timestamp=31341), **capab1),
              self.host_manager_1.service_states_last_update['host1'])
  
      @mock.patch(
          'cinder.scheduler.host_manager.HostManager.get_usage_and_notify')
      @mock.patch('oslo_utils.timeutils.utcnow')
      def test_update_and_notify_service_capabilities_case4(
              self, _mock_utcnow,
              _mock_get_usage_and_notify):
  
          _mock_utcnow.side_effect = [31346, 31347, 31348]
  
          service_name = 'volume'
  
          capab1 = {'pools': [{
                    'pool_name': 'pool1', 'thick_provisioning_support': True,
                    'thin_provisioning_support': False, 'total_capacity_gb': 10,
                    'free_capacity_gb': 10, 'max_over_subscription_ratio': '1',
                    'provisioned_capacity_gb': 0, 'allocated_capacity_gb': 0,
                    'reserved_percentage': 0}]}
  
          self.host_manager.service_states['host1'] = (
              dict(dict(timestamp=31344), **capab1))
          self.host_manager.service_states_last_update['host1'] = (
              dict(dict(timestamp=31340), **capab1))
          self.host_manager_1.service_states['host1'] = (
              dict(dict(timestamp=31345), **capab1))
          self.host_manager_1.service_states_last_update['host1'] = (
              dict(dict(timestamp=31341), **capab1))
  
          capab2 = {'pools': [{
                    'pool_name': 'pool1', 'thick_provisioning_support': True,
                    'thin_provisioning_support': False, 'total_capacity_gb': 10,
                    'free_capacity_gb': 9, 'max_over_subscription_ratio': '1',
                    'provisioned_capacity_gb': 1, 'allocated_capacity_gb': 1,
                    'reserved_percentage': 0}]}
  
          # Run 4:
          # capa: capab2
          # S0: update_service_capabilities()
          # S1: notify_service_capabilities()
          # S1: update_service_capabilities()
          #
          # notify capab2 to ceilometer.
  
          # S0: update_service_capabilities()
          self.host_manager.update_service_capabilities(service_name, 'host1',
                                                        capab2, None, None)
          self.assertDictEqual(
              dict(dict(timestamp=31340), **capab1),
              self.host_manager.service_states_last_update['host1'])
  
          self.assertDictEqual(dict(dict(timestamp=31346), **capab2),
                               self.host_manager.service_states['host1'])
  
          # S1: notify_service_capabilities()
          self.host_manager_1.notify_service_capabilities(service_name, 'host1',
                                                          capab2, None)
          self.assertDictEqual(dict(dict(timestamp=31345), **capab1),
                               self.host_manager_1.service_states['host1'])
  
          self.assertDictEqual(
              dict(dict(timestamp=31347), **capab2),
              self.host_manager_1.service_states_last_update['host1'])
  
          # notify capab2 to ceilometer.
          self.assertLess(0, _mock_get_usage_and_notify.call_count)
  
          # S1: update_service_capabilities()
          self.host_manager_1.update_service_capabilities(service_name, 'host1',
                                                          capab2, None, None)
          self.assertDictEqual(dict(dict(timestamp=31348), **capab2),
                               self.host_manager_1.service_states['host1'])
  
          self.assertDictEqual(
              dict(dict(timestamp=31347), **capab2),
              self.host_manager_1.service_states_last_update['host1'])
  
      @mock.patch(
          'cinder.scheduler.host_manager.HostManager.get_usage_and_notify')
      @mock.patch('oslo_utils.timeutils.utcnow')
      def test_update_and_notify_service_capabilities_case5(
              self, _mock_utcnow,
              _mock_get_usage_and_notify):
  
          _mock_utcnow.side_effect = [31349, 31350, 31351]
  
          service_name = 'volume'
  
          capab1 = {'pools': [{
                    'pool_name': 'pool1', 'thick_provisioning_support': True,
                    'thin_provisioning_support': False, 'total_capacity_gb': 10,
                    'free_capacity_gb': 10, 'max_over_subscription_ratio': '1',
                    'provisioned_capacity_gb': 0, 'allocated_capacity_gb': 0,
                    'reserved_percentage': 0}]}
  
          capab2 = {'pools': [{
                    'pool_name': 'pool1', 'thick_provisioning_support': True,
                    'thin_provisioning_support': False, 'total_capacity_gb': 10,
                    'free_capacity_gb': 9, 'max_over_subscription_ratio': '1',
                    'provisioned_capacity_gb': 1, 'allocated_capacity_gb': 1,
                    'reserved_percentage': 0}]}
  
          self.host_manager.service_states['host1'] = (
              dict(dict(timestamp=31346), **capab2))
          self.host_manager.service_states_last_update['host1'] = (
              dict(dict(timestamp=31340), **capab1))
          self.host_manager_1.service_states['host1'] = (
              dict(dict(timestamp=31348), **capab2))
          self.host_manager_1.service_states_last_update['host1'] = (
              dict(dict(timestamp=31347), **capab2))
  
          # Run 5:
          # capa: capa2
          # S0: notify_service_capabilities()
          # S0: update_service_capabilities()
          # S1: update_service_capabilities()
          #
          # This is the special case not handled.
          # 1) capab is changed (from capab1 to capab2)
          # 2) S1 has already notify the capab2 in Run 4.
          # 3) S0 just got update_service_capabilities() in Run 4.
          # 4) S0 got notify_service_capabilities() immediately in next run,
          #    here is Run 5.
          #    S0 has no ways to know whether other scheduler (here is S1) who
          #    has noitified the changed capab2 or not. S0 just thinks it's his
          #    own turn to notify the changed capab2.
          #    In this case, we have notified the same capabilities twice.
          #
          # S0: notify_service_capabilities()
          self.host_manager.notify_service_capabilities(service_name, 'host1',
                                                        capab2, None)
          self.assertDictEqual(
              dict(dict(timestamp=31349), **capab2),
              self.host_manager.service_states_last_update['host1'])
  
          self.assertDictEqual(dict(dict(timestamp=31346), **capab2),
                               self.host_manager.service_states['host1'])
  
          # S0 notify capab2 to ceilometer.
          self.assertLess(0, _mock_get_usage_and_notify.call_count)
  
          # S0: update_service_capabilities()
          self.host_manager.update_service_capabilities(service_name, 'host1',
                                                        capab2, None, None)
          self.assertDictEqual(
              dict(dict(timestamp=31349), **capab2),
              self.host_manager.service_states_last_update['host1'])
  
          self.assertDictEqual(dict(dict(timestamp=31350), **capab2),
                               self.host_manager.service_states['host1'])
  
          # S1: update_service_capabilities()
          self.host_manager_1.update_service_capabilities(service_name, 'host1',
                                                          capab2, None, None)
  
          self.assertDictEqual(
              dict(dict(timestamp=31348), **capab2),
              self.host_manager_1.service_states_last_update['host1'])
  
          self.assertDictEqual(dict(dict(timestamp=31351), **capab2),
                               self.host_manager_1.service_states['host1'])
  
      @mock.patch('cinder.objects.service.Service.is_up',
                  new_callable=mock.PropertyMock)
      @mock.patch('cinder.db.service_get_all')
      def test_has_all_capabilities(self, _mock_service_get_all,
                                    _mock_service_is_up):
          _mock_service_is_up.return_value = True
          services = [
              dict(id=1, host='host1', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='a3a593da-7f8d-4bb7-8b4c-f2bc1e0b4824'),
              dict(id=2, host='host2', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='4200b32b-0bf9-436c-86b2-0675f6ac218e'),
              dict(id=3, host='host3', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='6d91e7f5-ca17-4e3b-bf4f-19ca77166dd7'),
          ]
          _mock_service_get_all.return_value = services
          # Create host_manager again to let db.service_get_all mock run
          self.host_manager = host_manager.HostManager()
          self.assertFalse(self.host_manager.has_all_capabilities())
  
          timestamp = jsonutils.to_primitive(datetime.utcnow())
          host1_volume_capabs = dict(free_capacity_gb=4321)
          host2_volume_capabs = dict(free_capacity_gb=5432)
          host3_volume_capabs = dict(free_capacity_gb=6543)
  
          service_name = 'volume'
          self.host_manager.update_service_capabilities(service_name, 'host1',
                                                        host1_volume_capabs,
                                                        None, timestamp)
          self.assertFalse(self.host_manager.has_all_capabilities())
          self.host_manager.update_service_capabilities(service_name, 'host2',
                                                        host2_volume_capabs,
                                                        None, timestamp)
          self.assertFalse(self.host_manager.has_all_capabilities())
          self.host_manager.update_service_capabilities(service_name, 'host3',
                                                        host3_volume_capabs,
                                                        None, timestamp)
          self.assertTrue(self.host_manager.has_all_capabilities())
  
      @mock.patch('cinder.objects.service.Service.is_up',
                  new_callable=mock.PropertyMock)
      @mock.patch('cinder.db.service_get_all')
      def test_first_receive_capabilities_case1(self, _mock_service_get_all,
                                                _mock_service_is_up):
          # No volume service startup
          self.assertFalse(self.host_manager.first_receive_capabilities())
          services = [
              dict(id=1, host='host1', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='06acda71-b3b4-4f1b-8d87-db5c47e7ebd2', )
          ]
          _mock_service_get_all.return_value = services
          _mock_service_is_up.return_value = True
  
          timestamp = jsonutils.to_primitive(datetime.utcnow())
          host1_volume_capabs = dict(free_capacity_gb=4321)
  
          service_name = 'volume'
          self.host_manager.update_service_capabilities(service_name, 'host1',
                                                        host1_volume_capabs,
                                                        None, timestamp)
          self.assertTrue(self.host_manager.first_receive_capabilities())
  
      @mock.patch('cinder.objects.service.Service.is_up',
                  new_callable=mock.PropertyMock)
      @mock.patch('cinder.db.service_get_all')
      def test_first_receive_capabilities_case2(self, _mock_service_get_all,
                                                _mock_service_is_up):
          _mock_service_is_up.return_value = True
          services = [
              dict(id=1, host='host1', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='36ede0e2-1b3c-41b0-9cd3-66e1f56dc959'),
              dict(id=2, host='host2', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='b124e8dc-bf5f-4923-802d-27153ac7fe56'),
              dict(id=3, host='host3', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='4d0b1c5e-ce3c-424e-b2f4-a09a0f54d328'),
          ]
          _mock_service_get_all.return_value = services
          # Create host_manager again to let db.service_get_all mock run
          self.host_manager = host_manager.HostManager()
          self.assertFalse(self.host_manager.first_receive_capabilities())
  
          timestamp = jsonutils.to_primitive(datetime.utcnow())
          host1_volume_capabs = dict(free_capacity_gb=4321)
          host2_volume_capabs = dict(free_capacity_gb=5432)
          host3_volume_capabs = dict(free_capacity_gb=6543)
  
          service_name = 'volume'
          self.host_manager.update_service_capabilities(service_name, 'host1',
                                                        host1_volume_capabs,
                                                        None, timestamp)
          self.assertFalse(self.host_manager.first_receive_capabilities())
          self.host_manager.update_service_capabilities(service_name, 'host2',
                                                        host2_volume_capabs,
                                                        None, timestamp)
          self.assertFalse(self.host_manager.first_receive_capabilities())
          self.host_manager.update_service_capabilities(service_name, 'host3',
                                                        host3_volume_capabs,
                                                        None, timestamp)
          self.assertTrue(self.host_manager.first_receive_capabilities())
  
      @mock.patch('cinder.db.service_get_all')
      @mock.patch('cinder.objects.service.Service.is_up',
                  new_callable=mock.PropertyMock)
      @mock.patch('oslo_utils.timeutils.utcnow')
      def test_update_and_get_pools(self, _mock_utcnow,
                                    _mock_service_is_up,
                                    _mock_service_get_all):
          """Test interaction between update and get_pools
  
          This test verifies that each time that get_pools is called it gets the
          latest copy of service_capabilities, which is timestamped with the
          current date/time.
          """
          context = 'fake_context'
          dates = [datetime.fromtimestamp(400), datetime.fromtimestamp(401),
                   datetime.fromtimestamp(402)]
          _mock_utcnow.side_effect = dates
  
          services = [
              # This is the first call to utcnow()
              dict(id=1, host='host1', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='6d91e7f5-ca17-4e3b-bf4f-19ca77166dd7',)
          ]
  
          mocked_service_states = {
              'host1': dict(volume_backend_name='AAA',
                            total_capacity_gb=512, free_capacity_gb=200,
                            timestamp=dates[1], reserved_percentage=0),
          }
  
          _mock_service_get_all.return_value = services
          _mock_service_is_up.return_value = True
          _mock_warning = mock.Mock()
          host_manager.LOG.warn = _mock_warning
  
          host_volume_capabs = dict(free_capacity_gb=4321)
  
          service_name = 'volume'
          with mock.patch.dict(self.host_manager.service_states,
                               mocked_service_states):
              self.host_manager.update_service_capabilities(service_name,
                                                            'host1',
                                                            host_volume_capabs,
                                                            None, None)
              res = self.host_manager.get_pools(context)
              self.assertEqual(1, len(res))
              self.assertEqual(dates[1], res[0]['capabilities']['timestamp'])
  
      @mock.patch('cinder.objects.Service.is_up', True)
      def test_get_all_backend_states_cluster(self):
          """Test get_all_backend_states when we have clustered services.
  
          Confirm that clustered services are grouped and that only the latest
          of the capability reports is relevant.
          """
          ctxt = context.RequestContext(fake.USER_ID, fake.PROJECT_ID, True)
  
          cluster_name = 'cluster'
          db.cluster_create(ctxt, {'name': cluster_name,
                                   'binary': constants.VOLUME_BINARY})
  
          services = (
              db.service_create(ctxt,
                                {'host': 'clustered_host_1',
                                 'topic': constants.VOLUME_TOPIC,
                                 'binary': constants.VOLUME_BINARY,
                                 'cluster_name': cluster_name,
                                 'created_at': timeutils.utcnow()}),
              # Even if this service is disabled, since it belongs to an enabled
              # cluster, it's not really disabled.
              db.service_create(ctxt,
                                {'host': 'clustered_host_2',
                                 'topic': constants.VOLUME_TOPIC,
                                 'binary': constants.VOLUME_BINARY,
                                 'disabled': True,
                                 'cluster_name': cluster_name,
                                 'created_at': timeutils.utcnow()}),
              db.service_create(ctxt,
                                {'host': 'clustered_host_3',
                                 'topic': constants.VOLUME_TOPIC,
                                 'binary': constants.VOLUME_BINARY,
                                 'cluster_name': cluster_name,
                                 'created_at': timeutils.utcnow()}),
              db.service_create(ctxt,
                                {'host': 'non_clustered_host',
                                 'topic': constants.VOLUME_TOPIC,
                                 'binary': constants.VOLUME_BINARY,
                                 'created_at': timeutils.utcnow()}),
              # This service has no capabilities
              db.service_create(ctxt,
                                {'host': 'no_capabilities_host',
                                 'topic': constants.VOLUME_TOPIC,
                                 'binary': constants.VOLUME_BINARY,
                                 'created_at': timeutils.utcnow()}),
          )
  
          capabilities = ((1, {'free_capacity_gb': 1000}),
                          # This is the capacity that will be selected for the
                          # cluster because is the one with the latest timestamp.
                          (3, {'free_capacity_gb': 2000}),
                          (2, {'free_capacity_gb': 3000}),
                          (1, {'free_capacity_gb': 4000}))
  
          for i in range(len(capabilities)):
              self.host_manager.update_service_capabilities(
                  'volume', services[i].host, capabilities[i][1],
                  services[i].cluster_name, capabilities[i][0])
  
          res = self.host_manager.get_all_backend_states(ctxt)
          result = {(s.cluster_name or s.host, s.free_capacity_gb) for s in res}
          expected = {(cluster_name + '#_pool0', 2000),
                      ('non_clustered_host#_pool0', 4000)}
          self.assertSetEqual(expected, result)
  
      @mock.patch('cinder.db.service_get_all')
      @mock.patch('cinder.objects.service.Service.is_up',
                  new_callable=mock.PropertyMock)
      def test_get_all_backend_states(self, _mock_service_is_up,
                                      _mock_service_get_all):
          context = 'fake_context'
          timestamp = datetime.utcnow()
          topic = constants.VOLUME_TOPIC
  
          services = [
              dict(id=1, host='host1', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   binary=None, deleted=False, created_at=None, modified_at=None,
                   report_count=0, deleted_at=None, disabled_reason=None,
                   uuid='a3a593da-7f8d-4bb7-8b4c-f2bc1e0b4824'),
              dict(id=2, host='host2', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   binary=None, deleted=False, created_at=None, modified_at=None,
                   report_count=0, deleted_at=None, disabled_reason=None,
                   uuid='4200b32b-0bf9-436c-86b2-0675f6ac218e'),
              dict(id=3, host='host3', topic='volume', disabled=False,
                   availability_zone='zone2', updated_at=timeutils.utcnow(),
                   binary=None, deleted=False, created_at=None, modified_at=None,
                   report_count=0, deleted_at=None, disabled_reason=None,
                   uuid='6d91e7f5-ca17-4e3b-bf4f-19ca77166dd7'),
              dict(id=4, host='host4', topic='volume', disabled=False,
                   availability_zone='zone3', updated_at=timeutils.utcnow(),
                   binary=None, deleted=False, created_at=None, modified_at=None,
                   report_count=0, deleted_at=None, disabled_reason=None,
                   uuid='18417850-2ca9-43d1-9619-ae16bfb0f655'),
          ]
  
          service_objs = []
          for db_service in services:
              service_obj = objects.Service()
              service_objs.append(objects.Service._from_db_object(context,
                                                                  service_obj,
                                                                  db_service))
  
          service_states = {
              'host1': dict(volume_backend_name='AAA',
                            total_capacity_gb=512, free_capacity_gb=200,
                            timestamp=timestamp, reserved_percentage=0,
                            provisioned_capacity_gb=312),
              'host2': dict(volume_backend_name='BBB',
                            total_capacity_gb=256, free_capacity_gb=100,
                            timestamp=timestamp, reserved_percentage=0,
                            provisioned_capacity_gb=156),
              'host3': dict(volume_backend_name='CCC',
                            total_capacity_gb=10000, free_capacity_gb=700,
                            timestamp=timestamp, reserved_percentage=0,
                            provisioned_capacity_gb=9300),
          }
          # First test: service.is_up is always True, host5 is disabled,
          # host4 has no capabilities
          self.host_manager.service_states = service_states
          _mock_service_get_all.return_value = services
          _mock_service_is_up.return_value = True
          _mock_warning = mock.Mock()
          host_manager.LOG.warning = _mock_warning
  
          # Get all states
          self.host_manager.get_all_backend_states(context)
          _mock_service_get_all.assert_called_with(context,
                                                   disabled=False,
                                                   frozen=False,
                                                   topic=topic)
  
          # verify that Service.is_up was called for each srv
          expected = [mock.call() for s in service_objs]
          self.assertEqual(expected, _mock_service_is_up.call_args_list)
  
          # Get backend_state_map and make sure we have the first 3 hosts
          backend_state_map = self.host_manager.backend_state_map
          self.assertEqual(3, len(backend_state_map))
          for i in range(3):
              volume_node = services[i]
              host = volume_node['host']
              test_service.TestService._compare(self, volume_node,
                                                backend_state_map[host].service)
  
          # Second test: Now service.is_up returns False for host3
          _mock_service_is_up.reset_mock()
          _mock_service_is_up.side_effect = [True, True, False, True]
          _mock_service_get_all.reset_mock()
          _mock_warning.reset_mock()
  
          # Get all states, make sure host 3 is reported as down
          self.host_manager.get_all_backend_states(context)
          _mock_service_get_all.assert_called_with(context,
                                                   disabled=False,
                                                   frozen=False,
                                                   topic=topic)
  
          self.assertEqual(expected, _mock_service_is_up.call_args_list)
          self.assertGreater(_mock_warning.call_count, 0)
  
          # Get backend_state_map and make sure we have the first 2 hosts (host3
          # is down, host4 is missing capabilities)
          backend_state_map = self.host_manager.backend_state_map
          self.assertEqual(2, len(backend_state_map))
          for i in range(2):
              volume_node = services[i]
              host = volume_node['host']
              test_service.TestService._compare(self, volume_node,
                                                backend_state_map[host].service)
  
      @mock.patch('cinder.db.service_get_all')
      @mock.patch('cinder.objects.service.Service.is_up',
                  new_callable=mock.PropertyMock)
      def test_get_pools(self, _mock_service_is_up,
                         _mock_service_get_all):
          context = 'fake_context'
          timestamp = datetime.utcnow()
  
          services = [
              dict(id=1, host='host1', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='a3a593da-7f8d-4bb7-8b4c-f2bc1e0b4824'),
              dict(id=2, host='host2@back1', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='4200b32b-0bf9-436c-86b2-0675f6ac218e'),
              dict(id=3, host='host2@back2', topic='volume', disabled=False,
                   availability_zone='zone2', updated_at=timeutils.utcnow(),
                   uuid='6d91e7f5-ca17-4e3b-bf4f-19ca77166dd7'),
          ]
  
          mocked_service_states = {
              'host1': dict(volume_backend_name='AAA',
                            total_capacity_gb=512, free_capacity_gb=200,
                            timestamp=timestamp, reserved_percentage=0,
                            provisioned_capacity_gb=312),
              'host2@back1': dict(volume_backend_name='BBB',
                                  total_capacity_gb=256, free_capacity_gb=100,
                                  timestamp=timestamp, reserved_percentage=0,
                                  provisioned_capacity_gb=156),
              'host2@back2': dict(volume_backend_name='CCC',
                                  total_capacity_gb=10000, free_capacity_gb=700,
                                  timestamp=timestamp, reserved_percentage=0,
                                  provisioned_capacity_gb=9300),
          }
  
          _mock_service_get_all.return_value = services
          _mock_service_is_up.return_value = True
          _mock_warning = mock.Mock()
          host_manager.LOG.warn = _mock_warning
  
          with mock.patch.dict(self.host_manager.service_states,
                               mocked_service_states):
              res = self.host_manager.get_pools(context)
  
              # check if get_pools returns all 3 pools
              self.assertEqual(3, len(res))
  
              expected = [
                  {
                      'name': 'host1#AAA',
                      'capabilities': {
                          'timestamp': timestamp,
                          'volume_backend_name': 'AAA',
                          'free_capacity_gb': 200,
                          'driver_version': None,
                          'total_capacity_gb': 512,
                          'reserved_percentage': 0,
                          'vendor_name': None,
                          'storage_protocol': None,
                          'provisioned_capacity_gb': 312},
                  },
                  {
                      'name': 'host2@back1#BBB',
                      'capabilities': {
                          'timestamp': timestamp,
                          'volume_backend_name': 'BBB',
                          'free_capacity_gb': 100,
                          'driver_version': None,
                          'total_capacity_gb': 256,
                          'reserved_percentage': 0,
                          'vendor_name': None,
                          'storage_protocol': None,
                          'provisioned_capacity_gb': 156},
                  },
                  {
                      'name': 'host2@back2#CCC',
                      'capabilities': {
                          'timestamp': timestamp,
                          'volume_backend_name': 'CCC',
                          'free_capacity_gb': 700,
                          'driver_version': None,
                          'total_capacity_gb': 10000,
                          'reserved_percentage': 0,
                          'vendor_name': None,
                          'storage_protocol': None,
                          'provisioned_capacity_gb': 9300},
                  }
              ]
  
              def sort_func(data):
                  return data['name']
  
              self.assertEqual(len(expected), len(res))
              self.assertEqual(sorted(expected, key=sort_func),
                               sorted(res, key=sort_func))
  
      def test_get_usage(self):
          host = "host1@backend1"
          timestamp = 40000
          volume_stats1 = {'pools': [
                           {'pool_name': 'pool1',
                            'total_capacity_gb': 30.01,
                            'free_capacity_gb': 28.01,
                            'allocated_capacity_gb': 2.0,
                            'provisioned_capacity_gb': 2.0,
                            'max_over_subscription_ratio': '1.0',
                            'thin_provisioning_support': False,
                            'thick_provisioning_support': True,
                            'reserved_percentage': 5},
                           {'pool_name': 'pool2',
                            'total_capacity_gb': 20.01,
                            'free_capacity_gb': 18.01,
                            'allocated_capacity_gb': 2.0,
                            'provisioned_capacity_gb': 2.0,
                            'max_over_subscription_ratio': '2.0',
                            'thin_provisioning_support': True,
                            'thick_provisioning_support': False,
                            'reserved_percentage': 5}]}
  
          updated_pools1 = [{'pool_name': 'pool1',
                             'total_capacity_gb': 30.01,
                             'free_capacity_gb': 28.01,
                             'allocated_capacity_gb': 2.0,
                             'provisioned_capacity_gb': 2.0,
                             'max_over_subscription_ratio': '1.0',
                             'thin_provisioning_support': False,
                             'thick_provisioning_support': True,
                             'reserved_percentage': 5},
                            {'pool_name': 'pool2',
                             'total_capacity_gb': 20.01,
                             'free_capacity_gb': 18.01,
                             'allocated_capacity_gb': 2.0,
                             'provisioned_capacity_gb': 2.0,
                             'max_over_subscription_ratio': '2.0',
                             'thin_provisioning_support': True,
                             'thick_provisioning_support': False,
                             'reserved_percentage': 5}]
  
          volume_stats2 = {'pools': [
                           {'pool_name': 'pool1',
                            'total_capacity_gb': 30.01,
                            'free_capacity_gb': 28.01,
                            'allocated_capacity_gb': 2.0,
                            'provisioned_capacity_gb': 2.0,
                            'max_over_subscription_ratio': '2.0',
                            'thin_provisioning_support': True,
                            'thick_provisioning_support': False,
                            'reserved_percentage': 0},
                           {'pool_name': 'pool2',
                            'total_capacity_gb': 20.01,
                            'free_capacity_gb': 18.01,
                            'allocated_capacity_gb': 2.0,
                            'provisioned_capacity_gb': 2.0,
                            'max_over_subscription_ratio': '2.0',
                            'thin_provisioning_support': True,
                            'thick_provisioning_support': False,
                            'reserved_percentage': 5}]}
  
          updated_pools2 = [{'pool_name': 'pool1',
                             'total_capacity_gb': 30.01,
                             'free_capacity_gb': 28.01,
                             'allocated_capacity_gb': 2.0,
                             'provisioned_capacity_gb': 2.0,
                             'max_over_subscription_ratio': '2.0',
                             'thin_provisioning_support': True,
                             'thick_provisioning_support': False,
                             'reserved_percentage': 0}]
  
          expected1 = [
              {"name_to_id": 'host1@backend1#pool1',
               "type": "pool",
               "total": 30.01,
               "free": 28.01,
               "allocated": 2.0,
               "provisioned": 2.0,
               "virtual_free": 27.01,
               "reported_at": 40000},
              {"name_to_id": 'host1@backend1#pool2',
               "type": "pool",
               "total": 20.01,
               "free": 18.01,
               "allocated": 2.0,
               "provisioned": 2.0,
               "virtual_free": 37.02,
               "reported_at": 40000},
              {"name_to_id": 'host1@backend1',
               "type": "backend",
               "total": 50.02,
               "free": 46.02,
               "allocated": 4.0,
               "provisioned": 4.0,
               "virtual_free": 64.03,
               "reported_at": 40000}]
  
          expected2 = [
              {"name_to_id": 'host1@backend1#pool1',
               "type": "pool",
               "total": 30.01,
               "free": 28.01,
               "allocated": 2.0,
               "provisioned": 2.0,
               "virtual_free": 58.02,
               "reported_at": 40000},
              {"name_to_id": 'host1@backend1',
               "type": "backend",
               "total": 50.02,
               "free": 46.02,
               "allocated": 4.0,
               "provisioned": 4.0,
               "virtual_free": 95.04,
               "reported_at": 40000}]
  
          def sort_func(data):
              return data['name_to_id']
  
          res1 = self.host_manager._get_usage(volume_stats1,
                                              updated_pools1, host, timestamp)
          self.assertEqual(len(expected1), len(res1))
          self.assertEqual(sorted(expected1, key=sort_func),
                           sorted(res1, key=sort_func))
  
          res2 = self.host_manager._get_usage(volume_stats2,
                                              updated_pools2, host, timestamp)
          self.assertEqual(len(expected2), len(res2))
          self.assertEqual(sorted(expected2, key=sort_func),
                           sorted(res2, key=sort_func))
  
      @mock.patch('cinder.db.service_get_all')
      @mock.patch('cinder.objects.service.Service.is_up',
                  new_callable=mock.PropertyMock)
      def test_get_pools_filter_name(self, _mock_service_is_up,
                                     _mock_service_get_all_by_topic):
          context = 'fake_context'
  
          services = [
              dict(id=1, host='host1', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='a3a593da-7f8d-4bb7-8b4c-f2bc1e0b4824'),
              dict(id=2, host='host2@back1', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='4200b32b-0bf9-436c-86b2-0675f6ac218e')
          ]
  
          mocked_service_states = {
              'host1': dict(volume_backend_name='AAA',
                            total_capacity_gb=512, free_capacity_gb=200,
                            timestamp=None, reserved_percentage=0,
                            provisioned_capacity_gb=312),
              'host2@back1': dict(volume_backend_name='BBB',
                                  total_capacity_gb=256, free_capacity_gb=100,
                                  timestamp=None, reserved_percentage=0,
                                  provisioned_capacity_gb=156)
          }
  
          _mock_service_get_all_by_topic.return_value = services
          _mock_service_is_up.return_value = True
          _mock_warning = mock.Mock()
          host_manager.LOG.warn = _mock_warning
  
          with mock.patch.dict(self.host_manager.service_states,
                               mocked_service_states):
              filters = {'name': 'host1#AAA'}
              res = self.host_manager.get_pools(context, filters=filters)
  
              expected = [
                  {
                      'name': 'host1#AAA',
                      'capabilities': {
                          'timestamp': None,
                          'volume_backend_name': 'AAA',
                          'free_capacity_gb': 200,
                          'driver_version': None,
                          'total_capacity_gb': 512,
                          'reserved_percentage': 0,
                          'vendor_name': None,
                          'storage_protocol': None,
                          'provisioned_capacity_gb': 312},
                  }
              ]
  
              self.assertEqual(expected, res)
  
      @mock.patch('cinder.scheduler.host_manager.HostManager.'
                  '_choose_backend_filters')
      def test_get_pools_filtered_by_volume_type(self,
                                                 _mock_choose_backend_filters):
          context = 'fake_context'
          filter_class = FakeFilterClass3
          _mock_choose_backend_filters.return_value = [filter_class]
  
          hosts = {
              'host1': {'volume_backend_name': 'AAA',
                        'total_capacity_gb': 512,
                        'free_capacity_gb': 200,
                        'timestamp': None,
                        'reserved_percentage': 0,
                        'provisioned_capacity_gb': 312},
              'host2@back1': {'volume_backend_name': 'BBB',
                              'total_capacity_gb': 256,
                              'free_capacity_gb': 100,
                              'timestamp': None,
                              'reserved_percentage': 0,
                              'provisioned_capacity_gb': 156}}
          mock_warning = mock.Mock()
          host_manager.LOG.warn = mock_warning
          mock_volume_type = {
              'volume_backend_name': 'AAA',
              'qos_specs': 'BBB',
          }
          host_manager1 = host_manager.HostManager()
          res = host_manager1._filter_pools_by_volume_type(context,
                                                           mock_volume_type,
                                                           hosts)
          expected = {'host1': {'volume_backend_name': 'AAA',
                                'total_capacity_gb': 512,
                                'free_capacity_gb': 200,
                                'timestamp': None, 'reserved_percentage': 0,
                                'provisioned_capacity_gb': 312}}
  
          self.assertEqual(expected, res)
  
      @mock.patch('cinder.db.service_get_all')
      @mock.patch('cinder.objects.service.Service.is_up',
                  new_callable=mock.PropertyMock)
      def test_get_pools_filter_multiattach(self, _mock_service_is_up,
                                            _mock_service_get_all_by_topic):
          context = 'fake_context'
  
          services = [
              dict(id=1, host='host1', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='a3a593da-7f8d-4bb7-8b4c-f2bc1e0b4824'),
              dict(id=2, host='host2@back1', topic='volume', disabled=False,
                   availability_zone='zone1', updated_at=timeutils.utcnow(),
                   uuid='4200b32b-0bf9-436c-86b2-0675f6ac218e')
          ]
  
          mocked_service_states = {
              'host1': dict(volume_backend_name='AAA',
                            total_capacity_gb=512, free_capacity_gb=200,
                            timestamp=None, reserved_percentage=0,
                            multiattach=True),
              'host2@back1': dict(volume_backend_name='BBB',
                                  total_capacity_gb=256, free_capacity_gb=100,
                                  timestamp=None, reserved_percentage=0,
                                  multiattach=False)
          }
  
          _mock_service_get_all_by_topic.return_value = services
          _mock_service_is_up.return_value = True
          _mock_warning = mock.Mock()
          host_manager.LOG.warn = _mock_warning
  
          with mock.patch.dict(self.host_manager.service_states,
                               mocked_service_states):
              filters_t = {'multiattach': 'true'}
              filters_f = {'multiattach': False}
              res_t = self.host_manager.get_pools(context, filters=filters_t)
              res_f = self.host_manager.get_pools(context, filters=filters_f)
  
              expected_t = [
                  {
                      'name': 'host1#AAA',
                      'capabilities': {
                          'timestamp': None,
                          'volume_backend_name': 'AAA',
                          'free_capacity_gb': 200,
                          'driver_version': None,
                          'total_capacity_gb': 512,
                          'reserved_percentage': 0,
                          'vendor_name': None,
                          'storage_protocol': None,
                          'multiattach': True},
                  }
              ]
              expected_f = [
                  {
                      'name': 'host2@back1#BBB',
                      'capabilities': {
                          'timestamp': None,
                          'volume_backend_name': 'BBB',
                          'free_capacity_gb': 100,
                          'driver_version': None,
                          'total_capacity_gb': 256,
                          'reserved_percentage': 0,
                          'vendor_name': None,
                          'storage_protocol': None,
                          'multiattach': False},
                  }
              ]
  
              self.assertEqual(expected_t, res_t)
              self.assertEqual(expected_f, res_f)
  
      @ddt.data(
          (None, None, True),
          (None, 'value', False),
          ('cap', None, False),
          (False, 'True', False),
          (True, 'True', True),
          (True, True, True),
          (False, 'false', True),
          (1.1, '1.1', True),
          (0, '0', True),
          (1.1, '1.11', False),
          ('str', 'str', True),
          ('str1', 'str2', False),
          ('str', 'StR', False),
          ([], [], True),
          (['hdd', 'ssd'], ['ssd'], False),
          (['hdd', 'ssd'], ['ssd', 'hdd'], False),
          (['hdd', 'ssd'], "['hdd', 'ssd']", True),
          ({}, {}, True),
          ({'a': 'a', 'b': 'b'}, {'b': 'b', 'a': 'a'}, True),
          ({'a': 'a', 'b': 'b'}, {'b': 'b'}, False),
          ({'a': 'a'}, "{'a': 'a'}", True),
      )
      @ddt.unpack
      def test_equal_after_convert(self, cap, value, ret_value):
          self.assertEqual(ret_value,
                           self.host_manager._equal_after_convert(cap, value))
  
  
  class BackendStateTestCase(test.TestCase):
      """Test case for BackendState class."""
  
      def test_update_from_volume_capability_nopool(self):
          fake_backend = host_manager.BackendState('be1', None)
          self.assertIsNone(fake_backend.free_capacity_gb)
  
          volume_capability = {'total_capacity_gb': 1024,
                               'free_capacity_gb': 512,
                               'provisioned_capacity_gb': 512,
                               'reserved_percentage': 0,
                               'timestamp': None}
  
          fake_backend.update_from_volume_capability(volume_capability)
          # Backend level stats remain uninitialized
          self.assertEqual(0, fake_backend.total_capacity_gb)
          self.assertIsNone(fake_backend.free_capacity_gb)
          # Pool stats has been updated
          self.assertEqual(1024, fake_backend.pools['_pool0'].total_capacity_gb)
          self.assertEqual(512, fake_backend.pools['_pool0'].free_capacity_gb)
          self.assertEqual(512,
                           fake_backend.pools['_pool0'].provisioned_capacity_gb)
  
          # Test update for existing host state
          volume_capability.update(dict(total_capacity_gb=1000))
          fake_backend.update_from_volume_capability(volume_capability)
          self.assertEqual(1000, fake_backend.pools['_pool0'].total_capacity_gb)
  
          # Test update for existing host state with different backend name
          volume_capability.update(dict(volume_backend_name='magic'))
          fake_backend.update_from_volume_capability(volume_capability)
          self.assertEqual(1000, fake_backend.pools['magic'].total_capacity_gb)
          self.assertEqual(512, fake_backend.pools['magic'].free_capacity_gb)
          self.assertEqual(512,
                           fake_backend.pools['magic'].provisioned_capacity_gb)
          # 'pool0' becomes nonactive pool, and is deleted
          self.assertRaises(KeyError, lambda: fake_backend.pools['pool0'])
  
      def test_update_from_volume_capability_with_pools(self):
          fake_backend = host_manager.BackendState('host1', None)
          self.assertIsNone(fake_backend.free_capacity_gb)
          capability = {
              'volume_backend_name': 'Local iSCSI',
              'vendor_name': 'OpenStack',
              'driver_version': '1.0.1',
              'storage_protocol': 'iSCSI',
              'pools': [
                  {'pool_name': '1st pool',
                   'total_capacity_gb': 500,
                   'free_capacity_gb': 230,
                   'allocated_capacity_gb': 270,
                   'provisioned_capacity_gb': 270,
                   'QoS_support': 'False',
                   'reserved_percentage': 0,
                   'dying_disks': 100,
                   'super_hero_1': 'spider-man',
                   'super_hero_2': 'flash',
                   'super_hero_3': 'neoncat',
                   },
                  {'pool_name': '2nd pool',
                   'total_capacity_gb': 1024,
                   'free_capacity_gb': 1024,
                   'allocated_capacity_gb': 0,
                   'provisioned_capacity_gb': 0,
                   'QoS_support': 'False',
                   'reserved_percentage': 0,
                   'dying_disks': 200,
                   'super_hero_1': 'superman',
                   'super_hero_2': 'Hulk',
                   }
              ],
              'timestamp': None,
          }
  
          fake_backend.update_from_volume_capability(capability)
  
          self.assertEqual('Local iSCSI', fake_backend.volume_backend_name)
          self.assertEqual('iSCSI', fake_backend.storage_protocol)
          self.assertEqual('OpenStack', fake_backend.vendor_name)
          self.assertEqual('1.0.1', fake_backend.driver_version)
  
          # Backend level stats remain uninitialized
          self.assertEqual(0, fake_backend.total_capacity_gb)
          self.assertIsNone(fake_backend.free_capacity_gb)
          # Pool stats has been updated
          self.assertEqual(2, len(fake_backend.pools))
  
          self.assertEqual(500, fake_backend.pools['1st pool'].total_capacity_gb)
          self.assertEqual(230, fake_backend.pools['1st pool'].free_capacity_gb)
          self.assertEqual(
              270, fake_backend.pools['1st pool'].provisioned_capacity_gb)
          self.assertEqual(
              1024, fake_backend.pools['2nd pool'].total_capacity_gb)
          self.assertEqual(1024, fake_backend.pools['2nd pool'].free_capacity_gb)
          self.assertEqual(
              0, fake_backend.pools['2nd pool'].provisioned_capacity_gb)
  
          capability = {
              'volume_backend_name': 'Local iSCSI',
              'vendor_name': 'OpenStack',
              'driver_version': '1.0.2',
              'storage_protocol': 'iSCSI',
              'pools': [
                  {'pool_name': '3rd pool',
                   'total_capacity_gb': 10000,
                   'free_capacity_gb': 10000,
                   'allocated_capacity_gb': 0,
                   'provisioned_capacity_gb': 0,
                   'QoS_support': 'False',
                   'reserved_percentage': 0,
                   },
              ],
              'timestamp': None,
          }
  
          # test update BackendState Record
          fake_backend.update_from_volume_capability(capability)
  
          self.assertEqual('1.0.2', fake_backend.driver_version)
  
          # Non-active pool stats has been removed
          self.assertEqual(1, len(fake_backend.pools))
  
          self.assertRaises(KeyError, lambda: fake_backend.pools['1st pool'])
          self.assertRaises(KeyError, lambda: fake_backend.pools['2nd pool'])
  
          self.assertEqual(10000,
                           fake_backend.pools['3rd pool'].total_capacity_gb)
          self.assertEqual(10000,
                           fake_backend.pools['3rd pool'].free_capacity_gb)
          self.assertEqual(
              0, fake_backend.pools['3rd pool'].provisioned_capacity_gb)
  
      def test_update_from_volume_infinite_capability(self):
          fake_backend = host_manager.BackendState('host1', None)
          self.assertIsNone(fake_backend.free_capacity_gb)
  
          volume_capability = {'total_capacity_gb': 'infinite',
                               'free_capacity_gb': 'infinite',
                               'reserved_percentage': 0,
                               'timestamp': None}
  
          fake_backend.update_from_volume_capability(volume_capability)
          # Backend level stats remain uninitialized
          self.assertEqual(0, fake_backend.total_capacity_gb)
          self.assertIsNone(fake_backend.free_capacity_gb)
          # Pool stats has been updated
          self.assertEqual(
              'infinite',
              fake_backend.pools['_pool0'].total_capacity_gb)
          self.assertEqual(
              'infinite',
              fake_backend.pools['_pool0'].free_capacity_gb)
  
      def test_update_from_volume_unknown_capability(self):
          fake_backend = host_manager.BackendState('host1', None)
          self.assertIsNone(fake_backend.free_capacity_gb)
  
          volume_capability = {'total_capacity_gb': 'infinite',
                               'free_capacity_gb': 'unknown',
                               'reserved_percentage': 0,
                               'timestamp': None}
  
          fake_backend.update_from_volume_capability(volume_capability)
          # Backend level stats remain uninitialized
          self.assertEqual(0, fake_backend.total_capacity_gb)
          self.assertIsNone(fake_backend.free_capacity_gb)
          # Pool stats has been updated
          self.assertEqual(
              'infinite',
              fake_backend.pools['_pool0'].total_capacity_gb)
          self.assertEqual(
              'unknown',
              fake_backend.pools['_pool0'].free_capacity_gb)
  
      def test_update_from_empty_volume_capability(self):
          fake_backend = host_manager.BackendState('host1', None)
  
          vol_cap = {'timestamp': None}
  
          fake_backend.update_from_volume_capability(vol_cap)
          self.assertEqual(0, fake_backend.total_capacity_gb)
          self.assertIsNone(fake_backend.free_capacity_gb)
          # Pool stats has been updated
          self.assertEqual(0,
                           fake_backend.pools['_pool0'].total_capacity_gb)
          self.assertEqual(0,
                           fake_backend.pools['_pool0'].free_capacity_gb)
          self.assertEqual(0,
                           fake_backend.pools['_pool0'].provisioned_capacity_gb)
  
      def test_filter_goodness_default_capabilities(self):
          self.addCleanup(CONF.clear_override, 'filter_function')
          self.addCleanup(CONF.clear_override, 'goodness_function')
          CONF.set_override('filter_function', '2')
          CONF.set_override('goodness_function', '4')
  
          capability = {
              'filter_function': CONF.filter_function,
              'goodness_function': CONF.goodness_function,
              'timestamp': None,
              'pools': [{'pool_name': 'fake_pool'}]
          }
          fake_backend = host_manager.BackendState('host1', None)
  
          fake_backend.update_from_volume_capability(capability)
          pool_cap = fake_backend.pools['fake_pool']
  
          self.assertEqual('2', pool_cap.filter_function)
          self.assertEqual('4', pool_cap.goodness_function)
  
      def test_append_backend_info_custom_capabilities(self):
          pool_cap = {
              'pool_name': 'pool1',
              'total_capacity_gb': 30.01,
              'free_capacity_gb': 28.01,
              'allocated_capacity_gb': 2.0,
              'provisioned_capacity_gb': 2.0,
              'max_over_subscription_ratio': '1.0',
              'thin_provisioning_support': False,
              'thick_provisioning_support': True,
              'reserved_percentage': 5
          }
  
          volume_capability = {'filter_function': 5,
                               'goodness_function': 10}
          fake_backend = host_manager.BackendState(
              'host1', None, capabilities=volume_capability)
          fake_backend._append_backend_info(pool_cap)
  
          self.assertEqual(5, pool_cap['filter_function'])
          self.assertEqual(10, pool_cap['goodness_function'])
  
  
  class PoolStateTestCase(test.TestCase):
      """Test case for BackendState class."""
  
      def test_update_from_volume_capability(self):
          fake_pool = host_manager.PoolState('host1', None, None, 'pool0')
          self.assertIsNone(fake_pool.free_capacity_gb)
  
          volume_capability = {'total_capacity_gb': 1024,
                               'free_capacity_gb': 512,
                               'reserved_percentage': 0,
                               'provisioned_capacity_gb': 512,
                               'timestamp': None,
                               'cap1': 'val1',
                               'cap2': 'val2'}
  
          fake_pool.update_from_volume_capability(volume_capability)
          self.assertEqual('host1#pool0', fake_pool.host)
          self.assertEqual('pool0', fake_pool.pool_name)
          self.assertEqual(1024, fake_pool.total_capacity_gb)
          self.assertEqual(512, fake_pool.free_capacity_gb)
          self.assertEqual(512,
                           fake_pool.provisioned_capacity_gb)
  
          self.assertDictEqual(volume_capability, dict(fake_pool.capabilities))
  