de.flapdoodle.embed.mongo.MongodExecutable Java Examples

@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
    // configure a net binding instance
    Net mongoNet = this.getMongoNet();

    // register some autowire-able dependencies, to make leveraging the configured instances in a test possible
    applicationContext.getBeanFactory().registerResolvableDependency(RestTemplateBuilder.class, this.getRestTemplateBuilder());
    applicationContext.getBeanFactory().registerResolvableDependency(Net.class, mongoNet);
    applicationContext.getBeanFactory().registerResolvableDependency(MongodExecutable.class, this.getMongo(mongoNet));

    // configure the property sources that will be used by the application
    MutablePropertySources propertySources = applicationContext.getEnvironment().getPropertySources();
    MockPropertySource mockEnvVars = new MockPropertySource()
            .withProperty(Constants.ENV_DB_NAME, this.getDbName())
            .withProperty(Constants.ENV_DB_CONNSTR, "mongodb://localhost:" + mongoNet.getPort())
            .withProperty(Constants.ENV_ALLOWED_ORIGIN, this.getAllowedOrigin())
            .withProperty(Constants.ENV_EXCLUDE_FILTER, String.join(",", this.getExcludeList()));

    // inject the property sources into the application as environment variables
    propertySources.replace(StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, mockEnvVars);
}
 

@Override
public void afterPropertiesSet() throws Exception {
    final IMongodConfig mongodConfig = new MongodConfigBuilder()
            .version(Version.Main.PRODUCTION).build();

    IRuntimeConfig runtimeConfig = new RuntimeConfigBuilder()
            .defaultsWithLogger(Command.MongoD, logger)
            .processOutput(ProcessOutput.getDefaultInstanceSilent())
            .build();

    MongodStarter runtime = MongodStarter.getInstance(runtimeConfig);

    MongodExecutable mongodExecutable = runtime.prepare(mongodConfig);
    mongod = mongodExecutable.start();

    // cluster configuration
    ClusterSettings clusterSettings = ClusterSettings.builder().hosts(Collections.singletonList(new ServerAddress(mongodConfig.net().getServerAddress().getHostName(), mongodConfig.net().getPort()))).build();
    // codec configuration
    CodecRegistry pojoCodecRegistry = fromRegistries(MongoClients.getDefaultCodecRegistry(),
            fromProviders(PojoCodecProvider.builder().automatic(true).build()));

    MongoClientSettings settings = MongoClientSettings.builder().clusterSettings(clusterSettings).codecRegistry(pojoCodecRegistry).writeConcern(WriteConcern.ACKNOWLEDGED).build();
    mongoClient = MongoClients.create(settings);
    mongoDatabase = mongoClient.getDatabase(databaseName);
}
 

@Override
public void afterPropertiesSet() throws Exception {

    final IMongodConfig mongodConfig = new MongodConfigBuilder()
            .version(Version.Main.PRODUCTION).build();

    IRuntimeConfig runtimeConfig = new RuntimeConfigBuilder()
            .defaultsWithLogger(Command.MongoD, logger)
            .processOutput(ProcessOutput.getDefaultInstanceSilent())
            .build();

    MongodStarter runtime = MongodStarter.getInstance(runtimeConfig);

    MongodExecutable mongodExecutable = runtime.prepare(mongodConfig);
    mongod = mongodExecutable.start();

    // cluster configuration
    ClusterSettings clusterSettings = ClusterSettings.builder().hosts(Collections.singletonList(new ServerAddress(mongodConfig.net().getServerAddress().getHostName(), mongodConfig.net().getPort()))).build();
    // codec configuration
    CodecRegistry pojoCodecRegistry = fromRegistries(MongoClients.getDefaultCodecRegistry(),
            fromProviders(PojoCodecProvider.builder().automatic(true).build()));

    MongoClientSettings settings = MongoClientSettings.builder().clusterSettings(clusterSettings).codecRegistry(pojoCodecRegistry).writeConcern(WriteConcern.ACKNOWLEDGED).build();
    mongoClient = MongoClients.create(settings);
    mongoDatabase = mongoClient.getDatabase(databaseName);
}
 

private static MongodExecutable getMongodExecutable(IMongodConfig config) {
    try {
        return doGetExecutable(config);
    } catch (Exception e) {
        // sometimes the download process can timeout so just sleep and try again
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ignored) {

        }
        return doGetExecutable(config);
    }
}
 

private void startMongo(final List<IMongodConfig> mongodConfigList) throws IOException {
    // @formatter:off
    final ProcessOutput processOutput = new ProcessOutput(
            logTo(LOGGER, Slf4jLevel.INFO),
            logTo(LOGGER, Slf4jLevel.ERROR),
            named("[console>]", logTo(LOGGER, Slf4jLevel.DEBUG)));

    final IRuntimeConfig runtimeConfig = new RuntimeConfigBuilder()
            .defaultsWithLogger(Command.MongoD,LOGGER)
            .processOutput(processOutput)
            .artifactStore(new ExtractedArtifactStoreBuilder()
                .defaults(Command.MongoD)
                .download(new DownloadConfigBuilder()
                    .defaultsForCommand(Command.MongoD)
                    .progressListener(new Slf4jProgressListener(LOGGER))
                    .build()))
            .build();
    // @formatter:on
    final MongodStarter starter = MongodStarter.getInstance(runtimeConfig);

    for (final IMongodConfig mongodConfig : mongodConfigList) {
        final MongodExecutable mongodExecutable = starter.prepare(mongodConfig);
        final MongodProcess mongod = mongodExecutable.start();

        mongoProcesses.put(mongod, mongodExecutable);
    }
}
 

@BeforeClass
public static void initialize() throws IOException {
  MongodStarter starter = MongodStarter.getDefaultInstance();

  IMongodConfig mongodConfig = new MongodConfigBuilder()
      .version(Version.Main.PRODUCTION)
      .net(new Net(MONGO_PORT, Network.localhostIsIPv6()))
      .build();

  MongodExecutable mongodExecutable = starter.prepare(mongodConfig);
  MONGO = mongodExecutable.start();
}
 

private static MongodProcess tryToStartMongoDb(final MongodExecutable mongodExecutable) {
    try {
        return mongodExecutable.start();
    } catch (final IOException e) {
        throw new IllegalStateException("Failed to start MongoDB!", e);
    }
}
 

private static MongodExecutable configureMongoDb(final String bindIp,
        final int mongoDbPort,
        final IProxyFactory proxyFactory,
        final Logger logger) throws IOException {

    final Command command = Command.MongoD;

    final ProcessOutput processOutput;
    if (logger != null) {
        processOutput = ProcessOutput.getInstance("mongod", logger);
    } else {
        processOutput = ProcessOutput.getDefaultInstanceSilent();
    }

    final MongodStarter mongodStarter = MongodStarter.getInstance(new RuntimeConfigBuilder()
            .defaults(command)
            .processOutput(processOutput)
            .artifactStore(new ExtractedArtifactStoreBuilder()
                    .defaults(command)
                    .download(new DownloadConfigBuilder()
                            .defaultsForCommand(command)
                            .proxyFactory(proxyFactory)
                            .progressListener(new StandardConsoleProgressListener())
                            .build()))
            .build());

    return mongodStarter.prepare(new MongodConfigBuilder()
            .net(new Net(bindIp, mongoDbPort, false))
            .version(Version.Main.V3_6)
            .cmdOptions(new MongoCmdOptionsBuilder()
                    .useStorageEngine("wiredTiger")
                    .useNoJournal(false)
                    .build())
            .build());
}
 

private static MongodExecutable tryToConfigureMongoDb(final String bindIp,
        final int mongoDbPort,
        final IProxyFactory proxyFactory,
        final Logger logger) {

    try {
        return configureMongoDb(bindIp, mongoDbPort, proxyFactory, logger);
    } catch (final Throwable e) {
        return null;
    }
}
 

@Before
public void setup() throws IOException {
  processor = new TracingMongoClientPostProcessor(tracer);

  MongodStarter starter = MongodStarter.getDefaultInstance();
  MongodExecutable executable = starter.prepare(new MongodConfigBuilder()
      .version(Version.Main.PRODUCTION)
      .net(new Net(27017, Network.localhostIsIPv6()))
      .build());
  process = executable.start();
}
 

private static void startEmbeddedMongo() {
    final IStreamProcessor logDestination = new Slf4jStreamProcessor(LoggerFactory.getLogger("embeddeddmongo"), Slf4jLevel.INFO);
    final IStreamProcessor daemon = Processors.named("mongod", logDestination);
    final IStreamProcessor error = Processors.named("mongod-error", logDestination);
    final IStreamProcessor command = Processors.named("mongod-command", logDestination);
    final ProcessOutput processOutput = new ProcessOutput(daemon, error, command);
    final IRuntimeConfig runtimeConfig = new RuntimeConfigBuilder()
        .defaults(Command.MongoD)
        .artifactStore(new ExtractedArtifactStoreBuilder()
            .defaults(Command.MongoD)
            .extractDir(new FixedPath(".extracted"))
            .download(new DownloadConfigBuilder()
                .defaultsForCommand(Command.MongoD)
                .artifactStorePath(new FixedPath(".cache"))
                .build())
            .build())
        .processOutput(processOutput)
        .build();

    try {
        final IMongodConfig mongodConfig = createEmbeddedMongoConfiguration();

        final MongodExecutable mongodExecutable = MongodStarter.getInstance(runtimeConfig)
            .prepare(mongodConfig);


        mongodExecutable.start();
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

@Bean
public MongoClient mongoClient(final MongoProperties mongoProperties) throws IOException {
    String bindIp = mongoProperties.getHost()[0];
    int port = Network.getFreeServerPort();
    IMongodConfig mongodConfig = new MongodConfigBuilder()
            .version(Version.Main.PRODUCTION)
            .net(new Net(bindIp, port, Network.localhostIsIPv6()))
            .build();
    final MongodStarter runtime = MongodStarter.getInstance(new RuntimeConfigBuilder()
            .defaultsWithLogger(Command.MongoD, LOG)
            .build());
    MongodExecutable mongodExecutable = runtime.prepare(mongodConfig, Distribution.detectFor(Version.Main.PRODUCTION));
    mongodExecutable.start();
    return new MongoClient(bindIp, port);
}
 

private static MongodExecutable getMongodExecutable(IMongodConfig config) {
    try {
        return doGetExecutable(config);
    } catch (Exception e) {
        // sometimes the download process can timeout so just sleep and try again
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ignored) {

        }
        return doGetExecutable(config);
    }
}
 

@BeforeClass
public static void initialize() throws IOException {
  MongodStarter starter = MongodStarter.getDefaultInstance();

  IMongodConfig mongodConfig = new MongodConfigBuilder()
      .version(Version.Main.PRODUCTION)
      .net(new Net(MONGO_PORT, Network.localhostIsIPv6()))
      .build();

  MongodExecutable mongodExecutable = starter.prepare(mongodConfig);
  MONGO = mongodExecutable.start();
}
 

private void initializeConfigServer(IMongodConfig config) throws Exception {
	if (!config.isConfigServer()) {
		throw new Exception(
				"Mongo configuration is not a defined for a config server.");
	}
	MongodStarter starter = MongodStarter.getDefaultInstance();
	MongodExecutable mongodExe = starter.prepare(config);
	MongodProcess process = mongodExe.start();
	mongodProcessList.add(process);
}
 

private static MongodExecutable getMongodExecutable(IMongodConfig config) {
    try {
        return doGetExecutable(config);
    } catch (Exception e) {
        // sometimes the download process can timeout so just sleep and try again
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ignored) {

        }
        return doGetExecutable(config);
    }
}
 

public void startDB() throws Exception {
    MongodStarter starter = MongodStarter.getDefaultInstance();

    String bindIp = "localhost";
    int port = 27018;

    IMongodConfig mongodConfig = new MongodConfigBuilder()
            .version(Version.Main.PRODUCTION)
            .net(new Net(bindIp, port, Network.localhostIsIPv6()))
            .build();

    MongodExecutable mongodExecutable = null;

    mongodExecutable = starter.prepare(mongodConfig);

    //give time for previous DB close to finish and port to be released"
    Thread.sleep(200L);
    mongod = mongodExecutable.start();
    setClient();
}
 

private static MongodExecutable getMongodExecutable(IMongodConfig config) {
    try {
        return doGetExecutable(config);
    } catch (Exception e) {
        // sometimes the download process can timeout so just sleep and try again
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ignored) {

        }
        return doGetExecutable(config);
    }
}
 

private MongodExecutable getMongodExecutable(IMongodConfig config) {
    try {
        return doGetExecutable(config);
    } catch (Exception e) {
        // sometimes the download process can timeout so just sleep and try again
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ignored) {

        }
        return doGetExecutable(config);
    }
}
 

/**
 * Attempts to start a mongo instance, using embedMongo
 * @param bind the net info to bind to
 * @return the instance
 * @throws IOException indicates a failure
 */
private MongodExecutable setupMongoEmbed(Net bind) throws IOException {
    MongodStarter starter;
    starter = MongodStarter.getDefaultInstance();

    IMongodConfig mongodConfig = new MongodConfigBuilder()
            .version(Version.Main.DEVELOPMENT)
            .net(bind)
            .build();

    MongodExecutable mongodExecutable = starter.prepare(mongodConfig);
    MongodProcess mongod = mongodExecutable.start();
    return mongodExecutable;
}
 

private MongodExecutable getMongodExecutable(IMongodConfig config) {
    try {
        return doGetExecutable(config);
    } catch (Exception e) {
        // sometimes the download process can timeout so just sleep and try again
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ignored) {

        }
        return doGetExecutable(config);
    }
}
 

@BeforeClass
static void setUpMongo() throws IOException {
    MongodStarter starter = MongodStarter.getDefaultInstance();

    String bindIp = "localhost";
    int port = 27017;
    IMongodConfig mongodConfig = new MongodConfigBuilder()
            .version(Version.Main.DEVELOPMENT)
            .net(new Net(bindIp, port, Network.localhostIsIPv6()))
            .build();

    MongodExecutable mongodExecutable = starter.prepare(mongodConfig);
    MONGO_HOLDER.set(mongodExecutable);
    mongodExecutable.start();
}
 

/**
 * Setup a mongo instance
 * @param net the net instance to bind to
 * @return the mongo instance
 * @throws IOException thrown when unable to bind
 */
static MongodExecutable SetupMongo(Net net) throws IOException {
    MongodStarter starter = MongodStarter.getDefaultInstance();

    IMongodConfig mongodConfig = new MongodConfigBuilder()
            .version(Version.Main.DEVELOPMENT)
            .net(net)
            .build();

    MongodExecutable mongoProc = starter.prepare(mongodConfig);
    mongoProc.start();

    return mongoProc;
}
 

/**
 * Get the embedded mongo server instance
 * @param bind the net binding information to bind to
 * @return the embedded mongo server instance
 */
protected MongodExecutable getMongo(Net bind) {
    try {
        return Helpers.SetupMongo(bind);
    } catch (IOException e) {
        return null;
    }
}
 

public MongodExecutable getMongodExecutable() {
    return mongodExecutable;
}
 

public MongodExecutable getMongodExecutable() {
    return mongodExecutable;
}
 

static MongodExecutable prepareMongod(IMongodConfig config) {
  return INSTANCE.mongodStarter.prepare(config);
}
 

private static MongodExecutable doGetExecutable(IMongodConfig config) {
    return MongodStarter.getDefaultInstance().prepare(config);
}
 

private static MongodExecutable doGetExecutable(IMongodConfig config) {
    return MongodStarter.getDefaultInstance().prepare(config);
}
 

private static MongodExecutable doGetExecutable(IMongodConfig config) {
    return MongodStarter.getDefaultInstance().prepare(config);
}