def _new_configsvr(sharded_cluster: ShardedClusterFixture, is_multiversion: bool, old_bin_version: Optional[str]) -> ReplicaSetFixture: """Return a replica set fixture configured as the config server. :param sharded_cluster: sharded cluster fixture we are configuring config server for :param is_multiversion: whether we are in multiversion mode :param old_bin_version: old bin version :return: replica set fixture configured as the config server """ configsvr_logger = sharded_cluster.get_configsvr_logger() configsvr_kwargs = sharded_cluster.get_configsvr_kwargs() mixed_bin_versions = None if is_multiversion: # Our documented recommended path for upgrading shards lets us assume that config # server nodes will always be fully upgraded before shard nodes. mixed_bin_versions = [BinVersionEnum.NEW] * 2 return make_fixture("ReplicaSetFixture", configsvr_logger, sharded_cluster.job_num, mixed_bin_versions=mixed_bin_versions, old_bin_version=old_bin_version, **configsvr_kwargs)
def _new_rs_shard(sharded_cluster: ShardedClusterFixture, mixed_bin_versions: Optional[List[str]], old_bin_version: Optional[str], rs_shard_index: int, num_rs_nodes_per_shard: int) -> ReplicaSetFixture: """Return a replica set fixture configured as a shard in a sharded cluster. :param sharded_cluster: sharded cluster fixture we are configuring config server for :param mixed_bin_versions: the list of bin versions :param old_bin_version: old bin version :param rs_shard_index: replica set shard index :param num_rs_nodes_per_shard: the number of nodes in a replica set per shard :return: replica set fixture configured as a shard in a sharded cluster """ rs_shard_logger = sharded_cluster.get_rs_shard_logger(rs_shard_index) rs_shard_kwargs = sharded_cluster.get_rs_shard_kwargs(rs_shard_index) if mixed_bin_versions is not None: start_index = rs_shard_index * num_rs_nodes_per_shard mixed_bin_versions = mixed_bin_versions[start_index:start_index + num_rs_nodes_per_shard] return make_fixture("ReplicaSetFixture", rs_shard_logger, sharded_cluster.job_num, num_nodes=num_rs_nodes_per_shard, mixed_bin_versions=mixed_bin_versions, old_bin_version=old_bin_version, **rs_shard_kwargs)
def list_commands_for_api(api_version: str, mongod_or_mongos: str, install_dir: str) -> Set[str]: """Get a list of commands in a given API version by calling listCommands.""" assert mongod_or_mongos in ("mongod", "mongos") logging.info("Calling listCommands on %s", mongod_or_mongos) dbpath = TemporaryDirectory() mongod_executable = os.path.join(install_dir, "mongod") mongos_executable = os.path.join(install_dir, "mongos") if mongod_or_mongos == "mongod": logger = loggers.new_fixture_logger("MongoDFixture", 0) logger.parent = LOGGER fixture: interface.Fixture = MongoDFixture(logger, 0, dbpath_prefix=dbpath.name, mongod_executable=mongod_executable) else: logger = loggers.new_fixture_logger("ShardedClusterFixture", 0) logger.parent = LOGGER fixture = ShardedClusterFixture(logger, 0, dbpath_prefix=dbpath.name, mongos_executable=mongos_executable, mongod_executable=mongod_executable, mongod_options={}) fixture.setup() fixture.await_ready() try: client = MongoClient(fixture.get_driver_connection_url()) reply = client.admin.command('listCommands') commands = { name for name, info in reply['commands'].items() if api_version in info['apiVersions'] } logging.info("Found %s commands in API Version %s on %s", len(commands), api_version, mongod_or_mongos) return commands finally: fixture.teardown()
def _new_mongos(sharded_cluster: ShardedClusterFixture, executables: Dict[str, str], classes: Dict[str, str], mongos_index: int, total: int, is_multiversion: bool) -> FixtureContainer: """Make a fixture container with configured mongos fixture(s) in it. In non-multiversion mode only a new mongos fixture will be in the fixture container. In multiversion mode a new mongos and the old mongos fixtures will be in the container. :param sharded_cluster: sharded cluster fixture we are configuring mongos for :param executables: dict with a new and the old (if multiversion) mongos executable names :param classes: dict with a new and the old (if multiversion) mongos fixture names :param mongos_index: the index of mongos :param total: total number of mongos :param is_multiversion: whether we are in multiversion mode :return: fixture container with configured mongos fixture(s) in it """ mongos_logger = sharded_cluster.get_mongos_logger(mongos_index, total) mongos_kwargs = sharded_cluster.get_mongos_kwargs() old_fixture = None if is_multiversion: old_fixture = make_fixture( classes[BinVersionEnum.OLD], mongos_logger, sharded_cluster.job_num, mongos_executable=executables[BinVersionEnum.OLD], **mongos_kwargs) # We can't restart mongos since explicit ports are not supported. new_fixture_mongos_kwargs = sharded_cluster.get_mongos_kwargs() new_fixture = make_fixture( classes[BinVersionEnum.NEW], mongos_logger, sharded_cluster.job_num, mongos_executable=executables[BinVersionEnum.NEW], **new_fixture_mongos_kwargs) # Always spin up an old mongos if in multiversion mode given mongos is the last thing in the update path. return FixtureContainer( new_fixture, old_fixture, BinVersionEnum.OLD if is_multiversion else BinVersionEnum.NEW)