195 lines
8.1 KiB
Python
195 lines
8.1 KiB
Python
"""Facade wrapping the resmokelib dependencies used by fixtures."""
|
|
|
|
from logging import Handler, Logger
|
|
|
|
from buildscripts.resmokelib import config, core, errors, logging, utils
|
|
from buildscripts.resmokelib.core import network
|
|
from buildscripts.resmokelib.testing.fixtures import _builder
|
|
from buildscripts.resmokelib.utils.dictionary import merge_dicts
|
|
from buildscripts.resmokelib.utils.history import HistoryDict
|
|
from buildscripts.resmokelib.utils.history import make_historic as _make_historic
|
|
|
|
|
|
class FixtureLib:
|
|
"""Class that exposes the resmokelib API that fixtures can use."""
|
|
|
|
#################
|
|
# Logger tools #
|
|
#################
|
|
|
|
def assert_logger(self, logger: Logger):
|
|
"""Assert that the given logger has the correct type."""
|
|
if not isinstance(logger, Logger):
|
|
raise TypeError("logger must be a Logger instance")
|
|
|
|
def close_loggers(self, handler: Handler):
|
|
"""Add 'handler' to the queue so that it is closed later by the flush thread.
|
|
|
|
Return the scheduled event which may be used for later cancelation (see cancel()).
|
|
"""
|
|
return logging.flush.close_later(handler)
|
|
|
|
def new_fixture_node_logger(self, fixture_class, job_num, node_name):
|
|
"""Create a logger for a particular element in a multi-process fixture."""
|
|
return logging.loggers.new_fixture_node_logger(fixture_class, job_num, node_name)
|
|
|
|
############
|
|
# Programs #
|
|
############
|
|
|
|
def make_fixture(self, class_name, logger: logging.Logger, job_num: int, *args, **kwargs):
|
|
"""Build fixtures by calling builder API."""
|
|
return _builder.make_fixture(class_name, logger, job_num, *args, **kwargs)
|
|
|
|
def mongod_program(
|
|
self,
|
|
logger: logging.Logger,
|
|
job_num: int,
|
|
executable: str,
|
|
process_kwargs: dict,
|
|
mongod_options: HistoryDict,
|
|
) -> tuple["process.Process", HistoryDict]:
|
|
"""
|
|
Return a Process instance that starts mongod arguments constructed from 'mongod_options'.
|
|
|
|
@param logger - The logger to pass into the process.
|
|
@param executable - The mongod executable to run.
|
|
@param process_kwargs - A dict of key-value pairs to pass to the process.
|
|
@param mongod_options - A HistoryDict describing the various options to pass to the mongod.
|
|
"""
|
|
return core.programs.mongod_program(
|
|
logger, job_num, executable, process_kwargs, mongod_options
|
|
)
|
|
|
|
def mongos_program(
|
|
self,
|
|
logger: logging.Logger,
|
|
job_num: int,
|
|
executable=None,
|
|
process_kwargs=None,
|
|
mongos_options=None,
|
|
):
|
|
"""Return a Process instance that starts a mongos with arguments constructed from 'kwargs'."""
|
|
return core.programs.mongos_program(
|
|
logger, job_num, executable, process_kwargs, mongos_options
|
|
)
|
|
|
|
def mongot_program(
|
|
self,
|
|
logger: logging.Logger,
|
|
job_num: int,
|
|
executable=None,
|
|
process_kwargs=None,
|
|
mongot_options=None,
|
|
):
|
|
"""Return a Process instance that starts a mongot with arguments constructed from 'kwargs'."""
|
|
return core.programs.mongot_program(
|
|
logger, job_num, executable, process_kwargs, mongot_options
|
|
)
|
|
|
|
def generic_program(self, logger: logging.Logger, args, process_kwargs=None, **kwargs):
|
|
"""Return a Process instance that starts an arbitrary executable.
|
|
|
|
The executable arguments are constructed from 'kwargs'.
|
|
|
|
The args parameter is an array of strings containing the command to execute.
|
|
"""
|
|
return core.programs.generic_program(logger, args, process_kwargs, **kwargs)
|
|
|
|
#########
|
|
# Utils #
|
|
#########
|
|
|
|
ServerFailure = errors.ServerFailure
|
|
|
|
def make_historic(self, obj):
|
|
"""Convert a python object into a corresponding Historic to track history."""
|
|
return _make_historic(obj)
|
|
|
|
def default_if_none(self, *values):
|
|
"""Return the first argument that is not 'None'."""
|
|
return utils.default_if_none(*values)
|
|
|
|
def get_config(self):
|
|
"""Return an objects whose attributes are fixture config values."""
|
|
return _FixtureConfig()
|
|
|
|
def get_next_port(self, job_num):
|
|
"""Return the next available port that fixture can use."""
|
|
return network.PortAllocator.next_fixture_port(job_num)
|
|
|
|
SET_PARAMETERS_KEY = "set_parameters"
|
|
|
|
def merge_mongo_option_dicts(self, original: dict, override: dict):
|
|
"""
|
|
Merge mongod/s options such that --setParameter is merged recursively.
|
|
|
|
Values from `original` are replaced in-place with those of `override` where they exist.
|
|
"""
|
|
original_set_parameters = original.get(self.SET_PARAMETERS_KEY, {})
|
|
override_set_parameters = override.get(self.SET_PARAMETERS_KEY, {})
|
|
|
|
merged_set_parameters = merge_dicts(original_set_parameters, override_set_parameters)
|
|
original.update(override)
|
|
original[self.SET_PARAMETERS_KEY] = merged_set_parameters
|
|
|
|
return original
|
|
|
|
|
|
class _FixtureConfig(object):
|
|
"""Class that stores fixture configuration info."""
|
|
|
|
def __init__(self):
|
|
"""Initialize FixtureConfig, setting values."""
|
|
from buildscripts.resmokelib.multiversionconstants import (
|
|
LAST_CONTINUOUS_MONGOD_BINARY,
|
|
LAST_CONTINUOUS_MONGOS_BINARY,
|
|
LAST_LTS_MONGOD_BINARY,
|
|
LAST_LTS_MONGOS_BINARY,
|
|
)
|
|
|
|
self.MONGOD_EXECUTABLE = config.MONGOD_EXECUTABLE
|
|
self.DEFAULT_MONGOD_EXECUTABLE = config.DEFAULT_MONGOD_EXECUTABLE
|
|
self.MONGOD_SET_PARAMETERS = config.MONGOD_SET_PARAMETERS
|
|
self.MONGOD_EXTRA_CONFIG = config.MONGOD_EXTRA_CONFIG
|
|
self.FIXTURE_SUBDIR = config.FIXTURE_SUBDIR
|
|
self.AUTO_KILL = config.AUTO_KILL
|
|
self.ALWAYS_USE_LOG_FILES = config.ALWAYS_USE_LOG_FILES
|
|
self.LAST_LTS_MONGOD_BINARY = LAST_LTS_MONGOD_BINARY
|
|
self.LAST_LTS_MONGOS_BINARY = LAST_LTS_MONGOS_BINARY
|
|
self.LAST_CONTINUOUS_MONGOD_BINARY = LAST_CONTINUOUS_MONGOD_BINARY
|
|
self.LAST_CONTINUOUS_MONGOS_BINARY = LAST_CONTINUOUS_MONGOS_BINARY
|
|
self.USE_LEGACY_MULTIVERSION = config.USE_LEGACY_MULTIVERSION
|
|
self.ENABLED_FEATURE_FLAGS = config.ENABLED_FEATURE_FLAGS
|
|
self.IFR_FEATURE_FLAGS = config.IFR_FEATURE_FLAGS
|
|
self.EVERGREEN_TASK_ID = config.EVERGREEN_TASK_ID
|
|
self.MAJORITY_READ_CONCERN = config.MAJORITY_READ_CONCERN
|
|
self.NO_JOURNAL = config.NO_JOURNAL
|
|
self.STORAGE_ENGINE = config.STORAGE_ENGINE
|
|
self.STORAGE_ENGINE_CACHE_SIZE = config.STORAGE_ENGINE_CACHE_SIZE
|
|
self.STORAGE_ENGINE_CACHE_SIZE_PCT = config.STORAGE_ENGINE_CACHE_SIZE_PCT
|
|
self.MOZJS_JS_GC_ZEAL = config.MOZJS_JS_GC_ZEAL
|
|
self.WT_COLL_CONFIG = config.WT_COLL_CONFIG
|
|
self.WT_ENGINE_CONFIG = config.WT_ENGINE_CONFIG
|
|
self.WT_INDEX_CONFIG = config.WT_INDEX_CONFIG
|
|
self.MIXED_BIN_VERSIONS = config.MIXED_BIN_VERSIONS
|
|
self.LINEAR_CHAIN = config.LINEAR_CHAIN
|
|
self.TLS_MODE = config.TLS_MODE
|
|
self.TLS_CA_FILE = config.TLS_CA_FILE
|
|
self.SHELL_GRPC = config.SHELL_GRPC
|
|
self.SHELL_TLS_CERTIFICATE_KEY_FILE = config.SHELL_TLS_CERTIFICATE_KEY_FILE
|
|
self.NUM_REPLSET_NODES = config.NUM_REPLSET_NODES
|
|
self.NUM_SHARDS = config.NUM_SHARDS
|
|
self.DEFAULT_MONGOS_EXECUTABLE = config.DEFAULT_MONGOS_EXECUTABLE
|
|
self.MONGOS_EXECUTABLE = config.MONGOS_EXECUTABLE
|
|
self.MONGOS_SET_PARAMETERS = config.MONGOS_SET_PARAMETERS
|
|
self.DEFAULT_MONGOT_EXECUTABLE = config.DEFAULT_MONGOT_EXECUTABLE
|
|
self.MONGOT_EXECUTABLE = config.MONGOT_EXECUTABLE
|
|
self.DBPATH_PREFIX = config.DBPATH_PREFIX
|
|
self.DEFAULT_DBPATH_PREFIX = config.DEFAULT_DBPATH_PREFIX
|
|
self.DOCKER_COMPOSE_BUILD_IMAGES = config.DOCKER_COMPOSE_BUILD_IMAGES
|
|
self.NOOP_MONGO_D_S_PROCESSES = config.NOOP_MONGO_D_S_PROCESSES
|
|
self.CONFIG_FUZZER_ENCRYPTION_OPTS = config.CONFIG_FUZZER_ENCRYPTION_OPTS
|
|
self.LOAD_ALL_EXTENSIONS = config.LOAD_ALL_EXTENSIONS
|
|
self.SKIP_EXTENSIONS_SIGNATURE_VERIFICATION = config.SKIP_EXTENSIONS_SIGNATURE_VERIFICATION
|