# Copyright 2016 Cloudbase Solutions Srl
# 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.

import ddt
import mock
from nova.compute import power_state
from nova.compute import task_states
from nova.compute import vm_states
from nova import objects
from os_win import exceptions as os_win_exc

from compute_hyperv.nova.cluster import clusterops
from compute_hyperv.tests import fake_instance
from compute_hyperv.tests.unit import test_base


@ddt.ddt
class ClusterOpsTestCase(test_base.HyperVBaseTestCase):
    """Unit tests for the Hyper-V ClusterOps class."""

    _FAKE_INSTANCE_NAME = 'fake_instance_name'

    @mock.patch('nova.network.API')
    def setUp(self, mock_network_api):
        super(ClusterOpsTestCase, self).setUp()
        self.context = 'fake_context'

        self.clusterops = clusterops.ClusterOps()
        self.clusterops._context = self.context
        self.clusterops._clustutils = mock.MagicMock()
        self.clusterops._vmutils = mock.MagicMock()
        self.clusterops._network_api = mock.MagicMock()
        self.clusterops._vmops = mock.MagicMock()
        self.clusterops._serial_console_ops = mock.MagicMock()
        self._clustutils = self.clusterops._clustutils

    def test_get_instance_host(self):
        mock_instance = fake_instance.fake_instance_obj(self.context)
        self.clusterops.get_instance_host(mock_instance)

        self.clusterops._clustutils.get_vm_host.assert_called_once_with(
            mock_instance.name)

    def test_add_to_cluster(self):
        mock_instance = fake_instance.fake_instance_obj(self.context)
        self.clusterops.add_to_cluster(mock_instance)

        mock_add_vm = self.clusterops._clustutils.add_vm_to_cluster
        mock_add_vm.assert_called_once_with(mock_instance.name)
        self.assertEqual(mock_instance.uuid,
                         self.clusterops._instance_map[mock_instance.name])

    @mock.patch.object(clusterops, 'LOG')
    def test_add_to_cluster_exception(self, mock_LOG):
        mock_instance = fake_instance.fake_instance_obj(self.context)
        mock_add_vm = self.clusterops._clustutils.add_vm_to_cluster
        mock_add_vm.side_effect = os_win_exc.HyperVClusterException

        self.clusterops.add_to_cluster(mock_instance)
        self.assertTrue(mock_LOG.exception.called)

    def test_remove_from_cluster(self):
        mock_instance = fake_instance.fake_instance_obj(self.context)
        self.clusterops.remove_from_cluster(mock_instance)

        self.clusterops._clustutils.vm_exists.assert_called_once_with(
            mock_instance.name)
        self.clusterops._clustutils.delete.assert_called_once_with(
            mock_instance.name)
        self.assertIsNone(self.clusterops._instance_map.get(
            mock_instance.name))

    @mock.patch.object(clusterops, 'LOG')
    def test_remove_from_cluster_exception(self, mock_LOG):
        mock_instance = fake_instance.fake_instance_obj(self.context)
        mock_delete = self.clusterops._clustutils.delete
        mock_delete.side_effect = os_win_exc.HyperVClusterException

        self.clusterops.remove_from_cluster(mock_instance)
        self.assertTrue(mock_LOG.exception.called)

    def test_post_migration(self):
        mock_instance = fake_instance.fake_instance_obj(self.context)
        self.clusterops.post_migration(mock_instance)

        self.assertEqual(
            self.clusterops._instance_map[mock_instance.name],
            mock_instance.uuid)

    @mock.patch('nova.utils.spawn_n')
    def test_start_failover_listener_daemon(self, mock_spawn):
        self.clusterops.start_failover_listener_daemon()

        spawn_args = mock_spawn.call_args_list[0][0]
        self.assertEqual(
            self._clustutils.get_vm_owner_change_listener.return_value,
            spawn_args[0])

        cbk = spawn_args[1]
        cbk()

        mock_spawn.assert_called_with(self.clusterops._failover_migrate)

    @mock.patch('nova.utils.spawn_n')
    @mock.patch.object(clusterops.ClusterOps, '_failover_migrate')
    @mock.patch.object(clusterops.ClusterOps, '_get_nova_instances')
    def test_reclaim_failovered_instances(self, mock_get_instances,
                                          mock_failover_migrate,
                                          mock_spawn):
        self.clusterops._this_node = 'fake_node'
        mock_instance1 = mock.MagicMock(host='other_host')
        mock_instance2 = mock.MagicMock(host=self.clusterops._this_node)
        mock_get_instances.return_value = [mock_instance1, mock_instance2]

        self.clusterops.reclaim_failovered_instances()

        self.clusterops._vmops.list_instance_uuids.assert_called_once_with()
        mock_get_instances.assert_called_once_with(
            ['id', 'uuid', 'name', 'host'],
            self.clusterops._vmops.list_instance_uuids.return_value)
        mock_spawn.assert_called_once_with(
            mock_failover_migrate,
            mock_instance1.name, mock_instance1.host,
            self.clusterops._this_node)

    @mock.patch.object(clusterops, 'LOG')
    @mock.patch.object(clusterops.ClusterOps, '_get_instance_by_name')
    def test_failover_migrate_no_instance(self, mock_get_instance_by_name,
                                          mock_LOG):
        mock_get_instance_by_name.return_value = None

        self.clusterops._failover_migrate(mock.sentinel.instance_name,
                                          mock.sentinel.old_host,
                                          mock.sentinel.new_host)

        mock_LOG.debug.assert_called_once_with(
            'Instance %s does not exist in nova. Skipping.',
            mock.sentinel.instance_name)
        self.assertFalse(
            self.clusterops._network_api.get_instance_nw_info.called)

    @mock.patch.object(clusterops, 'LOG')
    @mock.patch.object(clusterops.ClusterOps, '_get_instance_by_name')
    def test_failover_migrate_migrating(self, mock_get_instance_by_name,
                                        mock_LOG):
        instance = mock_get_instance_by_name.return_value
        instance.task_state = task_states.MIGRATING

        self.clusterops._failover_migrate(mock.sentinel.instance_name,
                                          mock.sentinel.old_host,
                                          mock.sentinel.new_host)

        mock_LOG.debug.assert_called_once_with(
            'Instance %s is live migrating.', mock.sentinel.instance_name)

    @mock.patch.object(clusterops.ClusterOps, '_get_instance_by_name')
    def test_failover_migrate_same_host(self, mock_get_instance_by_name):
        instance = mock_get_instance_by_name.return_value
        instance.host = self.clusterops._this_node

        self.clusterops._failover_migrate(mock.sentinel.instance_name,
                                          mock.sentinel.old_host,
                                          mock.sentinel.new_host)

        self.assertFalse(
            self.clusterops._network_api.get_instance_nw_info.called)

    @mock.patch.object(clusterops.ClusterOps, '_get_instance_by_name')
    def test_failover_migrate_at_source_node(self, mock_get_instance_by_name):
        instance = mock_get_instance_by_name.return_value
        old_host = 'old_host'
        self.clusterops._this_node = old_host

        self.clusterops._failover_migrate(mock.sentinel.instance_name,
                                          old_host, mock.sentinel.new_host)

        self.clusterops._vmops.unplug_vifs.assert_called_once_with(instance,
            self.clusterops._network_api.get_instance_nw_info.return_value)

    @mock.patch.object(clusterops, 'LOG')
    @mock.patch.object(clusterops.ClusterOps, '_get_instance_by_name')
    def test_failover_migrate_not_this_node(self, mock_get_instance_by_name,
                                            mock_LOG):
        self.clusterops._this_node = 'new_host'

        self.clusterops._failover_migrate(mock.sentinel.instance_name,
                                          None, 'host')

        mock_LOG.debug.assert_called_once_with(
            'Instance %s did not failover to this node.',
            mock.sentinel.instance_name)

    @mock.patch.object(clusterops.ClusterOps, '_failover_migrate_networks')
    @mock.patch.object(clusterops.ClusterOps, '_nova_failover_server')
    @mock.patch.object(clusterops.ClusterOps, '_get_instance_by_name')
    def test_failover_migrate_this_node(self, mock_get_instance_by_name,
                                        mock_nova_failover_server,
                                        mock_failover_migrate_networks):
        instance = mock_get_instance_by_name.return_value
        old_host = 'old_host'
        new_host = 'new_host'
        self.clusterops._this_node = new_host

        self.clusterops._failover_migrate(mock.sentinel.instance_name,
                                          old_host, new_host)

        mock_get_instance_by_name.assert_called_once_with(
            mock.sentinel.instance_name)
        get_inst_nw_info = self.clusterops._network_api.get_instance_nw_info
        get_inst_nw_info.assert_called_once_with(self.clusterops._context,
                                                 instance)
        mock_nova_failover_server.assert_called_once_with(instance, new_host)
        mock_failover_migrate_networks.assert_called_once_with(
            instance, old_host)
        self.clusterops._vmops.plug_vifs.assert_called_once_with(
            instance, get_inst_nw_info.return_value)
        c_handler = self.clusterops._serial_console_ops.start_console_handler
        c_handler.assert_called_once_with(mock.sentinel.instance_name)

    def test_failover_migrate_networks(self):
        mock_instance = fake_instance.fake_instance_obj(self.context)
        fake_source = mock.MagicMock()
        fake_migration = {'source_compute': fake_source,
                          'dest_compute': self.clusterops._this_node}

        self.clusterops._failover_migrate_networks(mock_instance,
                                                    fake_source)

        mock_network_api = self.clusterops._network_api
        calls = [mock.call(self.clusterops._context, mock_instance,
                           self.clusterops._this_node),
                 mock.call(self.clusterops._context, mock_instance,
                           self.clusterops._this_node),
                 mock.call(self.clusterops._context, mock_instance,
                           self.clusterops._this_node),
                 mock.call(self.clusterops._context, mock_instance,
                           fake_source, teardown=True)]
        mock_network_api.setup_networks_on_host.assert_has_calls(calls)
        mock_network_api.migrate_instance_start.assert_called_once_with(
            self.clusterops._context, mock_instance, fake_migration)
        mock_network_api.migrate_instance_finish.assert_called_once_with(
            self.clusterops._context, mock_instance, fake_migration)

    @mock.patch.object(objects.Instance, 'get_by_uuid')
    def test_get_instance_by_name(self, mock_get_by_uuid):
        mock_instance = fake_instance.fake_instance_obj(self.context)
        mock_get_by_uuid.return_value = mock_instance
        self.clusterops._instance_map[mock_instance.name] = mock_instance.uuid

        ret = self.clusterops._get_instance_by_name(mock_instance.name)
        self.assertEqual(ret, mock_instance)

    @mock.patch.object(objects.Instance, 'get_by_uuid')
    def test_get_instance_by_name_not_in_cache(self, mock_get_by_uuid):
        mock_instance = fake_instance.fake_instance_obj(self.context)
        self.clusterops._vmutils.get_instance_uuid.return_value = (
            mock_instance.uuid)
        mock_get_by_uuid.return_value = mock_instance

        ret = self.clusterops._get_instance_by_name(mock_instance.name)
        self.assertEqual(ret, mock_instance)
        self.assertEqual(mock_instance.uuid,
                         self.clusterops._instance_map[mock_instance.name])

    @mock.patch.object(objects.Instance, 'get_by_uuid')
    def test_get_instance_by_name_not_update_map(self, mock_get_by_uuid):
        mock_instance = fake_instance.fake_instance_obj(self.context)
        self.clusterops._vmutils.get_instance_uuid.side_effect = (
            os_win_exc.HyperVVMNotFoundException(vm_name=mock_instance.name))
        self.clusterops._update_instance_map = mock.MagicMock()
        self.clusterops._instance_map = mock.MagicMock()
        self.clusterops._instance_map.get.side_effect = [None,
                                                          mock_instance.uuid]
        mock_get_by_uuid.return_value = mock_instance

        ret = self.clusterops._get_instance_by_name(mock_instance.name)
        self.assertEqual(ret, mock_instance)
        self.clusterops._update_instance_map.assert_called_with()

    @mock.patch.object(clusterops.ClusterOps, '_get_nova_instances')
    def test_update_instance_map(self, mock_get_instances):
        mock_instance = mock.MagicMock(uuid=mock.sentinel.uuid)
        mock_instance.configure_mock(name=mock.sentinel.name)
        mock_get_instances.return_value = [mock_instance]

        self.clusterops._update_instance_map()

        self.assertEqual(mock.sentinel.uuid,
                         self.clusterops._instance_map[mock.sentinel.name])

    @ddt.data({'instance_uuids': None},
              {'instance_uuids': []},
              {'instance_uuids': mock.sentinel.uuid})
    @ddt.unpack
    @mock.patch.object(clusterops.objects.InstanceList, 'get_by_filters')
    def test_get_nova_instances(self, mock_get_by_filters, instance_uuids):
        instances = self.clusterops._get_nova_instances(
            instance_uuids=instance_uuids)

        self.assertEqual(mock_get_by_filters.return_value, instances)
        expected_attrs = ['id', 'uuid', 'name']
        expected_filters = {'deleted': False}
        if instance_uuids is not None:
            expected_filters['uuid'] = instance_uuids
        mock_get_by_filters.assert_called_once_with(
            self.clusterops._context, expected_filters,
            expected_attrs=expected_attrs)

    @mock.patch.object(clusterops.block_device, 'DriverVolumeBlockDevice')
    @mock.patch.object(clusterops.objects.BlockDeviceMappingList,
                       'get_by_instance_uuid')
    def test_get_instance_block_device_mappings(self, mock_get_by_uuid,
                                                mock_DriverVBD):
        mock_get_by_uuid.return_value = [mock.sentinel.bdm]
        mock_instance = mock.MagicMock()

        bdms = self.clusterops._get_instance_block_device_mappings(
            mock_instance)

        self.assertEqual([mock_DriverVBD.return_value], bdms)
        mock_get_by_uuid.assert_called_once_with(self.clusterops._context,
                                                 mock_instance.uuid)
        mock_DriverVBD.assert_called_once_with(mock.sentinel.bdm)

    def test_nova_failover_server(self):
        mock_instance = mock.MagicMock(vm_state=vm_states.ERROR,
                                       power_state=power_state.NOSTATE)

        self.clusterops._nova_failover_server(mock_instance,
                                               mock.sentinel.host)

        self.assertEqual(vm_states.ACTIVE, mock_instance.vm_state)
        self.assertEqual(power_state.RUNNING, mock_instance.power_state)
        self.assertEqual(mock.sentinel.host, mock_instance.host)
        self.assertEqual(mock.sentinel.host, mock_instance.node)
        mock_instance.save.assert_called_once_with(expected_task_state=[None])