def initialize_database_for_testing(self, db_file_path=None): """Initialize a SQLite database for testing. To force monitor_db and the host_scheduler to use the same SQLite file database, call this method before initializing the database through frontend_test_utils. The host_scheduler is setup to look for the host_scheduler_db when invoked with --testing. @param db_file_path: The name of the file to use to create a SQLite database. Since this database is shared across different processes using a file is closer to the real world. """ if not db_file_path: db_file_path = self.DB_FILE # TODO: Move the translating database elsewhere. Monitor_db circular # imports host_scheduler. from autotest_lib.frontend import setup_test_environment from django.conf import settings self.old_django_db_name = settings.DATABASES['default']['NAME'] settings.DATABASES['default']['NAME'] = db_file_path self.db_file_path = db_file_path _db_manager = scheduler_lib.ConnectionManager(autocommit=False) _db_manager.db_connection = ( database_connection.TranslatingDatabase.get_test_database( translators=scheduler_lib._DB_TRANSLATORS))
def _set_monitor_stubs(self): self.mock_config = global_config.FakeGlobalConfig() self.god.stub_with(global_config, 'global_config', self.mock_config) # Clear the instance cache as this is a brand new database. scheduler_models.DBObject._clear_instance_cache() self._database = ( database_connection.TranslatingDatabase.get_test_database( translators=scheduler_lib._DB_TRANSLATORS)) self._database.connect(db_type='django') self._database.debug = _DEBUG connection_manager = scheduler_lib.ConnectionManager(autocommit=False) self.god.stub_with(connection_manager, 'db_connection', self._database) self.god.stub_with(monitor_db, '_db_manager', connection_manager) self.god.stub_with(monitor_db, '_db', self._database) self.god.stub_with(monitor_db.BaseDispatcher, '_get_pending_queue_entries', self._get_pending_hqes) self.god.stub_with(scheduler_models, '_db', self._database) self.god.stub_with(drone_manager.instance(), '_results_dir', '/test/path') self.god.stub_with(drone_manager.instance(), '_temporary_directory', '/test/path/tmp') self.god.stub_with(drone_manager.instance(), 'initialize', lambda *args: None) self.god.stub_with(drone_manager.instance(), 'execute_actions', lambda *args: None) monitor_db.initialize_globals() scheduler_models.initialize_globals()
def testConnectionManagerSingleton(self): """Test that the singleton works as expected.""" # Confirm that instantiating the class applies global db settings. connection_manager = scheduler_lib.ConnectionManager() readonly_connection.set_globally_disabled.assert_called_once_with(True) setup_django_environment.enable_autocommit.assert_called_once_with() readonly_connection.set_globally_disabled.reset_mock() setup_django_environment.enable_autocommit.reset_mock() # Confirm that instantiating another connection manager doesn't change # the database settings, and in fact, returns the original manager. connection_manager_2 = scheduler_lib.ConnectionManager() self.assertTrue(connection_manager == connection_manager_2) self.assertTrue( readonly_connection.set_globally_disabled.call_count == 0) self.assertTrue( setup_django_environment.enable_autocommit.call_count == 0) # Confirm that we don't open the connection when the class is # instantiated. self.assertTrue(connection_manager.db_connection is None)
def testConnectionReconnect(self): """Test that retries don't destroy the connection.""" database_connection._DjangoBackend.execute = mock.MagicMock() database_connection._DjangoBackend.execute.side_effect = ( django_utils.DatabaseError('Database Error')) connection_manager = scheduler_lib.ConnectionManager() connection = connection_manager.get_connection() self.assertRaises(django_utils.DatabaseError, connection.execute, *('', None, True)) self.assertTrue( database_connection._DjangoBackend.execute.call_count == 2) database_connection._DjangoBackend.execute.reset_mock() self.assertTrue(connection_manager.db_connection == connection_manager.get_connection())
def testConnectionDisconnect(self): """Test connection and disconnecting from the database.""" # Test that the connection manager only opens a connection once. connection_manager = scheduler_lib.ConnectionManager() connection_manager.open_connection = mock.MagicMock() connection = connection_manager.get_connection() connection_manager.open_connection.assert_called_once_with() connection_manager.open_connection.reset_mock() connection = connection_manager.get_connection() self.assertTrue(connection_manager.open_connection.call_count == 0) connection_manager.open_connection.reset_mock() # Test that del on the connection manager closes the connection connection_manager.disconnect = mock.MagicMock() connection_manager.__del__() connection_manager.disconnect.assert_called_once_with()
def initialize(testing=False): """Initialize the host scheduler.""" if testing: # Don't import testing utilities unless we're in testing mode, # as the database imports have side effects. from autotest_lib.scheduler import rdb_testing_utils rdb_testing_utils.FileDatabaseHelper().initialize_database_for_testing( db_file_path=rdb_testing_utils.FileDatabaseHelper.DB_FILE) global _db_manager _db_manager = scheduler_lib.ConnectionManager() scheduler_lib.setup_logging(os.environ.get('AUTOTEST_SCHEDULER_LOG_DIR', None), None, timestamped_logfile_prefix='host_scheduler') logging.info("Setting signal handler") signal.signal(signal.SIGINT, handle_signal) signal.signal(signal.SIGTERM, handle_signal) scheduler_models.initialize()
def setUp(self, inline_host_acquisition=True, setup_tables=True): """Common setup module for tests that need a jobs/host database. @param inline_host_acquisition: If True, the dispatcher tries to acquire hosts inline with the rest of the tick. """ self.db_helper = DBHelper() self._database = self.db_helper.database # Runs syncdb setting up initial database conditions self._frontend_common_setup(setup_tables=setup_tables) connection_manager = scheduler_lib.ConnectionManager(autocommit=False) self.god.stub_with(connection_manager, 'db_connection', self._database) self.god.stub_with(monitor_db, '_db_manager', connection_manager) self.god.stub_with(scheduler_models, '_db', self._database) self.god.stub_with(monitor_db, '_inline_host_acquisition', inline_host_acquisition) self._dispatcher = monitor_db.Dispatcher() self.host_scheduler = self._dispatcher._host_scheduler self.host_query_manager = query_managers.AFEHostQueryManager() self.job_query_manager = self._dispatcher._job_query_manager self._release_unused_hosts()
def initialize(): global _db _db = scheduler_lib.ConnectionManager().get_connection() notify_statuses_list = global_config.global_config.get_config_value( scheduler_config.CONFIG_SECTION, "notify_email_statuses", default='') global _notify_email_statuses _notify_email_statuses = [ status for status in re.split(r'[\s,;:]', notify_statuses_list.lower()) if status ] # AUTOTEST_WEB.base_url is still a supported config option as some people # may wish to override the entire url. global _base_url config_base_url = global_config.global_config.get_config_value( scheduler_config.CONFIG_SECTION, 'base_url', default='') if config_base_url: _base_url = config_base_url else: _base_url = afe_urls.ROOT_URL initialize_globals()
def __init__(self): """Create an AFEHostQueryManager. @param db: A connection to the database with the afe_hosts table. """ self._db = scheduler_lib.ConnectionManager().get_connection()