Python context.get_context函数代码示例

 def test_get_context_no_overwrite(self):
     # If there is already a context in the cache creating another context
     # should not overwrite it.
     ctx1 = context.RequestContext('111',
                                   '222',
                                   overwrite=True)
     context.get_context()
     self.assertIs(ctx1, o_context.get_current())

    def test_scatter_gather_cells(self, mock_get_inst, mock_target_cell):
        ctxt = context.get_context()
        mapping = objects.CellMapping(database_connection='fake://db',
                                      transport_url='fake://mq',
                                      uuid=uuids.cell)
        mappings = objects.CellMappingList(objects=[mapping])

        # Use a mock manager to assert call order across mocks.
        manager = mock.Mock()
        manager.attach_mock(mock_get_inst, 'get_inst')
        manager.attach_mock(mock_target_cell, 'target_cell')

        filters = {'deleted': False}
        context.scatter_gather_cells(
            ctxt, mappings, 60, objects.InstanceList.get_by_filters, filters,
            sort_dir='foo')

        # NOTE(melwitt): This only works without the SpawnIsSynchronous fixture
        # because when the spawn is treated as synchronous and the thread
        # function is called immediately, it will occur inside the target_cell
        # context manager scope when it wouldn't with a real spawn.

        # Assert that InstanceList.get_by_filters was called before the
        # target_cell context manager exited.
        get_inst_call = mock.call.get_inst(
            mock_target_cell.return_value.__enter__.return_value, filters,
            sort_dir='foo')
        expected_calls = [get_inst_call,
                          mock.call.target_cell().__exit__(None, None, None)]
        manager.assert_has_calls(expected_calls)

    def _setup_cells(self):
        """Setup a normal cellsv2 environment.

        This sets up the CellDatabase fixture with two cells, one cell0
        and one normal cell. CellMappings are created for both so that
        cells-aware code can find those two databases.
        """
        celldbs = nova_fixtures.CellDatabases()
        celldbs.add_cell_database(objects.CellMapping.CELL0_UUID)
        celldbs.add_cell_database(uuids.cell1, default=True)
        self.useFixture(celldbs)

        ctxt = context.get_context()
        fake_transport = 'fake://nowhere/'

        c0 = objects.CellMapping(
            context=ctxt,
            uuid=objects.CellMapping.CELL0_UUID,
            name='cell0',
            transport_url=fake_transport,
            database_connection=objects.CellMapping.CELL0_UUID)
        c0.create()

        c1 = objects.CellMapping(
            context=ctxt,
            uuid=uuids.cell1,
            name=CELL1_NAME,
            transport_url=fake_transport,
            database_connection=uuids.cell1)
        c1.create()

        self.cell_mappings = {cm.name: cm for cm in (c0, c1)}

    def test_scatter_gather_cells_timeout(self, mock_get_inst,
                                          mock_get_result, mock_timeout,
                                          mock_log_warning):
        # This is needed because we're mocking get_by_filters.
        self.useFixture(nova_fixtures.SpawnIsSynchronousFixture())
        ctxt = context.get_context()
        mapping0 = objects.CellMapping(database_connection='fake://db0',
                                       transport_url='none:///',
                                       uuid=objects.CellMapping.CELL0_UUID)
        mapping1 = objects.CellMapping(database_connection='fake://db1',
                                       transport_url='fake://mq1',
                                       uuid=uuids.cell1)
        mappings = objects.CellMappingList(objects=[mapping0, mapping1])

        # Simulate cell1 not responding.
        mock_get_result.side_effect = [(mapping0.uuid,
                                        mock.sentinel.instances),
                                       exception.CellTimeout()]

        results = context.scatter_gather_cells(
            ctxt, mappings, 30, objects.InstanceList.get_by_filters)
        self.assertEqual(2, len(results))
        self.assertIn(mock.sentinel.instances, results.values())
        self.assertIn(context.did_not_respond_sentinel, results.values())
        mock_timeout.assert_called_once_with(30, exception.CellTimeout)
        self.assertTrue(mock_log_warning.called)

 def test_fallback(self):
     # Convert RequestContext, should get a dict.
     primitive = rpc.JsonPayloadSerializer.fallback(context.get_context())
     self.assertIsInstance(primitive, dict)
     # Convert anything else, should get a string.
     primitive = rpc.JsonPayloadSerializer.fallback(mock.sentinel.entity)
     self.assertIsInstance(primitive, six.text_type)

    def test_new_websocket_client_db(
            self, mock_ca_check, mock_validate_port, mock_inst_get,
            mock_validate, internal_access_path=None,
            instance_not_found=False):

        db_obj = self._fake_console_db(
            host='node1',
            port=10000,
            console_type='novnc',
            access_url_base='https://example.net:6080',
            internal_access_path=internal_access_path,
            instance_uuid=uuids.instance,
            # This is set by ConsoleAuthToken.validate
            token='123-456-789'
        )
        ctxt = nova_context.get_context()
        obj = nova.objects.ConsoleAuthToken._from_db_object(
            ctxt, nova.objects.ConsoleAuthToken(), db_obj)
        mock_validate.return_value = obj

        if instance_not_found:
            mock_inst_get.side_effect = exception.InstanceNotFound(
                instance_id=uuids.instance)

        if internal_access_path is None:
            self.wh.socket.return_value = '<socket>'
        else:
            tsock = mock.MagicMock()
            tsock.recv.return_value = "HTTP/1.1 200 OK\r\n\r\n"
            self.wh.socket.return_value = tsock

        self.wh.path = "http://127.0.0.1/?token=123-456-789"
        self.wh.headers = self.fake_header

        if instance_not_found:
            self.assertRaises(exception.InvalidToken,
                              self.wh.new_websocket_client)
        else:
            with mock.patch('nova.context.get_admin_context',
                            return_value=ctxt):
                self.wh.new_websocket_client()

            mock_validate.called_once_with(ctxt, '123-456-789')
            mock_validate_port.assert_called_once_with(
                ctxt, mock_inst_get.return_value, str(db_obj['port']),
                db_obj['console_type'])
            mock_ca_check.assert_not_called()

            self.wh.socket.assert_called_with('node1', 10000, connect=True)

            if internal_access_path is None:
                self.wh.do_proxy.assert_called_with('<socket>')
            else:
                self.wh.do_proxy.assert_called_with(tsock)

 def test_cinderclient_unsupported_v2(self, get_api_version):
     """Tests that we fail if trying to use Cinder v2."""
     self.flags(catalog_info='volumev2:cinderv2:publicURL', group='cinder')
     # setup mocks
     get_endpoint = mock.Mock(
         return_value='http://localhost:8776/v2/%(project_id)s')
     fake_session = mock.Mock(get_endpoint=get_endpoint)
     ctxt = context.get_context()
     with mock.patch.object(cinder, '_SESSION', fake_session):
         self.assertRaises(exception.UnsupportedCinderAPIVersion,
                           cinder.cinderclient, ctxt)
     get_api_version.assert_called_once_with(get_endpoint.return_value)

    def start_service(self, name, host=None, **kwargs):
        svc = self.useFixture(
            nova_fixtures.ServiceFixture(name, host, **kwargs))

        if name == 'compute' and self.USES_DB:
            ctxt = context.get_context()
            cell = self.cell_mappings[kwargs.pop('cell', CELL1_NAME)]
            hm = objects.HostMapping(context=ctxt,
                                     host=svc.service.host,
                                     cell_mapping=cell)
            hm.create()
            self.host_mappings[hm.host] = hm

        return svc.service

    def test_scatter_gather_single_cell(self, mock_scatter):
        ctxt = context.get_context()
        mapping0 = objects.CellMapping(database_connection='fake://db0',
                                       transport_url='none:///',
                                       uuid=objects.CellMapping.CELL0_UUID)

        filters = {'deleted': False}
        context.scatter_gather_single_cell(ctxt, mapping0,
            objects.InstanceList.get_by_filters, filters, sort_dir='foo')

        mock_scatter.assert_called_once_with(
            ctxt, [mapping0], context.CELL_TIMEOUT,
            objects.InstanceList.get_by_filters, filters,
            sort_dir='foo')

    def test_scatter_gather_cells(self, mock_get_inst, mock_target_cell):
        self.useFixture(nova_fixtures.SpawnIsSynchronousFixture())
        ctxt = context.get_context()
        mapping = objects.CellMapping(database_connection='fake://db',
                                      transport_url='fake://mq',
                                      uuid=uuids.cell)
        mappings = objects.CellMappingList(objects=[mapping])

        filters = {'deleted': False}
        context.scatter_gather_cells(
            ctxt, mappings, 60, objects.InstanceList.get_by_filters, filters,
            sort_dir='foo')

        mock_get_inst.assert_called_once_with(
            mock_target_cell.return_value.__enter__.return_value, filters,
            sort_dir='foo')

    def start_service(self, name, host=None, **kwargs):
        if name == 'compute' and self.USES_DB:
            # NOTE(danms): We need to create the HostMapping first, because
            # otherwise we'll fail to update the scheduler while running
            # the compute node startup routines below.
            ctxt = context.get_context()
            cell = self.cell_mappings[kwargs.pop('cell', CELL1_NAME)]
            hm = objects.HostMapping(context=ctxt,
                                     host=host or name,
                                     cell_mapping=cell)
            hm.create()
            self.host_mappings[hm.host] = hm

        svc = self.useFixture(
            nova_fixtures.ServiceFixture(name, host, **kwargs))

        return svc.service

    def test_scatter_gather_skip_cell0(self, mock_get_all, mock_scatter):
        ctxt = context.get_context()
        mapping0 = objects.CellMapping(database_connection='fake://db0',
                                       transport_url='none:///',
                                       uuid=objects.CellMapping.CELL0_UUID)
        mapping1 = objects.CellMapping(database_connection='fake://db1',
                                       transport_url='fake://mq1',
                                       uuid=uuids.cell1)
        mock_get_all.return_value = objects.CellMappingList(
            objects=[mapping0, mapping1])

        filters = {'deleted': False}
        context.scatter_gather_skip_cell0(
            ctxt, objects.InstanceList.get_by_filters, filters, sort_dir='foo')

        mock_scatter.assert_called_once_with(
            ctxt, [mapping1], 60, objects.InstanceList.get_by_filters, filters,
            sort_dir='foo')

 def test_target_cell_caching(self, mock_create_cm, mock_create_tport):
     mock_create_cm.return_value = mock.sentinel.db_conn_obj
     mock_create_tport.return_value = mock.sentinel.mq_conn_obj
     ctxt = context.get_context()
     mapping = objects.CellMapping(database_connection='fake://db',
                                   transport_url='fake://mq',
                                   uuid=uuids.cell)
     # First call should create new connection objects.
     with context.target_cell(ctxt, mapping) as cctxt:
         self.assertEqual(mock.sentinel.db_conn_obj, cctxt.db_connection)
         self.assertEqual(mock.sentinel.mq_conn_obj, cctxt.mq_connection)
     mock_create_cm.assert_called_once_with('fake://db')
     mock_create_tport.assert_called_once_with('fake://mq')
     # Second call should use cached objects.
     mock_create_cm.reset_mock()
     mock_create_tport.reset_mock()
     with context.target_cell(ctxt, mapping) as cctxt:
         self.assertEqual(mock.sentinel.db_conn_obj, cctxt.db_connection)
         self.assertEqual(mock.sentinel.mq_conn_obj, cctxt.mq_connection)
     mock_create_cm.assert_not_called()
     mock_create_tport.assert_not_called()

    def start_service(self, name, host=None, **kwargs):
        cell = None
        if name == 'compute' and self.USES_DB:
            # NOTE(danms): We need to create the HostMapping first, because
            # otherwise we'll fail to update the scheduler while running
            # the compute node startup routines below.
            ctxt = context.get_context()
            cell_name = kwargs.pop('cell', CELL1_NAME) or CELL1_NAME
            cell = self.cell_mappings[cell_name]
            hm = objects.HostMapping(context=ctxt,
                                     host=host or name,
                                     cell_mapping=cell)
            hm.create()
            self.host_mappings[hm.host] = hm
            if host is not None:
                # Make sure that CONF.host is relevant to the right hostname
                self.useFixture(nova_fixtures.ConfPatcher(host=host))
        svc = self.useFixture(
            nova_fixtures.ServiceFixture(name, host, cell=cell, **kwargs))

        return svc.service

    def test_scatter_gather_cells_exception(self, mock_get_inst,
                                            mock_log_exception):
        # This is needed because we're mocking get_by_filters.
        self.useFixture(nova_fixtures.SpawnIsSynchronousFixture())
        ctxt = context.get_context()
        mapping0 = objects.CellMapping(database_connection='fake://db0',
                                       transport_url='none:///',
                                       uuid=objects.CellMapping.CELL0_UUID)
        mapping1 = objects.CellMapping(database_connection='fake://db1',
                                       transport_url='fake://mq1',
                                       uuid=uuids.cell1)
        mappings = objects.CellMappingList(objects=[mapping0, mapping1])

        # Simulate cell1 raising an exception.
        mock_get_inst.side_effect = [mock.sentinel.instances,
                                     test.TestingException()]

        results = context.scatter_gather_cells(
            ctxt, mappings, 30, objects.InstanceList.get_by_filters)
        self.assertEqual(2, len(results))
        self.assertIn(mock.sentinel.instances, results.values())
        self.assertIn(context.raised_exception_sentinel, results.values())
        self.assertTrue(mock_log_exception.called)