Java RiverSettings类代码示例

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
public SnapshotsSettings(RiverSettings settings) {
	super();
	if (settings.settings().containsKey(RIVERNAME)) {
		@SuppressWarnings({ "unchecked" })
		Map<String, Object> snapshotterSettings = (Map<String, Object>) settings.settings().get(RIVERNAME);
		this.repository = XContentMapValues.nodeStringValue(snapshotterSettings.get("repository"), "my_backup");
		this.indices = XContentMapValues.nodeStringValue(snapshotterSettings.get("indices"), "_all");
		this.includeGlobalState = XContentMapValues.nodeBooleanValue(snapshotterSettings.get("include_global_state"), false);
		this.frequency = TimeValue.parseTimeValue(XContentMapValues.nodeStringValue(snapshotterSettings.get("frequency"), "24h"), TimeValue.timeValueMinutes(60));
		if (snapshotterSettings.get("purgeAfter") != null && snapshotterSettings.get("purgeAfter").toString().length() > 0) {
			this.purgeAfter = TimeValue.parseTimeValue(XContentMapValues.nodeStringValue(snapshotterSettings.get("purgeAfter"), "240h"), TimeValue.timeValueHours(240));
		} else {
			this.purgeAfter = null;
		}
		this.setPurgeIndicesMustMatch(XContentMapValues.nodeBooleanValue(snapshotterSettings.get("purge_indices_must_match"), true));

	} else {
		this.repository = "my_backup";
		this.indices = "_all";
		this.includeGlobalState = false;
		this.frequency = TimeValue.timeValueHours(24);
		this.purgeAfter = null; // no purging by default
		this.setPurgeIndicesMustMatch(true);
	}
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
@Inject
public BigQueryRiver(final RiverName riverName, final RiverSettings settings, final Client esClient) {
	super(riverName, settings);
	this.esClient = esClient;
	logger.info("Creating BigQuery Stream River");
	indexScript = readConfig("index", riverName.name());
	typeScript = readConfig("type", "import");
	project = readConfig("project");
	keyFile = readConfig("keyFile");
	account = readConfig("account");
	query = readConfig("query");
	mappingScript = readConfig("mapping", null);
	create = Boolean.valueOf(readConfig("create", null));
	uniqueIdField = readConfig("uniqueIdField", null);
	interval = Long.parseLong(readConfig("interval", "600000"));
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
private Feeder createFeeder(String riverType, String riverName, RiverSettings riverSettings) {
    JDBCFeeder feeder = null;
    try {
        Map<String, Object> spec = (Map<String, Object>) riverSettings.settings().get("jdbc");
        Map<String, String> loadedSettings = new JsonSettingsLoader().load(jsonBuilder().map(spec).string());
        Settings mySettings = settingsBuilder().put(loadedSettings).build();
        String strategy = XContentMapValues.nodeStringValue(spec.get("strategy"), "simple");
        RiverFlow riverFlow = RiverServiceLoader.findRiverFlow(strategy);
        logger.debug("found river flow class {} for strategy {}", riverFlow.getClass().getName(), strategy);
        feeder = riverFlow.getFeeder();
        logger.debug("spec = {} settings = {}", spec, mySettings.getAsMap());
        feeder.setName(riverName)
                .setType(riverType)
                .setSpec(spec).setSettings(mySettings);
    } catch (IOException e) {
        logger.error(e.getMessage(), e);
    }
    return feeder;
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
public void testDefaults()
{
	Map<String, Object> map = new HashMap<>();		
	RiverSettings settings = new RiverSettings(
		ImmutableSettings.settingsBuilder().build(), 
		map);
	KafkaRiverConfig c = new KafkaRiverConfig(settings);
	
	assertEquals("localhost", c.brokerHost);
	assertEquals(9092, c.brokerPort);
	assertEquals("localhost", c.zookeeper);
	assertEquals(10485760, c.bulkSize);
	assertEquals(0, c.partition);
	assertEquals("default_topic", c.topic);
	assertEquals(10000, c.bulkTimeout.millis());
	
	assertEquals("org.elasticsearch.river.kafka.JsonMessageHandlerFactory", c.factoryClass);
	
	assertEquals(-1, c.statsdPort);
	assertNull(c.statsdHost);
	assertNull(c.statsdPrefix);
	
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
@Inject
protected GitRiver(RiverName riverName, RiverSettings settings, @RiverIndexName String riverIndexName, Client client) throws InvocationTargetException, IllegalAccessException {
    super(riverName, settings);
    this.client = client;
    logger.info("Creating Git river");

    if (settings.settings().containsKey("git")) {
        Map<String, Object> gitSettings = (Map<String, Object>) settings.settings().get("git");
        BeanUtilsBean2.getInstance().populate(context, transformKeys(gitSettings, new Function<String, String>() {
            @Override
            public String apply(String input) {
                return CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, input);
            }
        }));
    }
    context.setRiverName(riverName.name());
    context.setRiverIndexName(riverIndexName);
    context.setClient(client);
    context.setIssuePattern(compilePattern(context.getIssueRegex()));
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
@Inject
public ArangoDbRiver( //
final RiverName riverName, //
	final RiverSettings settings, //
	final Client client, //
	final ScriptService scriptService, //
	final ArangoDbConfig config, //
	final WalReaderRunnable walReaderRunnable, //
	final IndexWriterRunnable indexWriterRunnable, //
	@Named("arangodb_river_walReaderRunnable_threadfactory") final ThreadFactory walReaderThreadFactory, //
	@Named("arangodb_river_indexWriterRunnable_threadfactory") final ThreadFactory indexWriterThreadFactory //
) throws ArangoDbException {

	super(riverName, settings);

	this.client = client;
	this.config = config;
	this.walReaderRunnable = walReaderRunnable;
	this.indexWriterRunnable = indexWriterRunnable;
	this.walReaderThreadFactory = walReaderThreadFactory;
	this.indexWriterThreadFactory = indexWriterThreadFactory;

	logger.debug("Prefix: [{}] - name: [{}]", logger.getPrefix(), logger.getName());
	logger.debug("River settings: [{}]", settings.settings());
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
@SuppressWarnings({"unchecked"})
@Inject
public WildlfyRiver(RiverName riverName, RiverSettings settings, Client client, ThreadPool threadPool) {
    super(riverName, settings);
    this.client = client;
    this.threadPool = threadPool;

    logger.info("Creating wildfly metric stream");

    indexName = riverName.name();
    typeName = "metrics";

    //dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'");

    timeFormatter = ISODateTimeFormat.dateTimeNoMillis();

}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
/**
 * Prepare {@link RemoteRiver} instance for unit test, with Mockito moceked jiraClient and elasticSearchClient.
 * 
 * @param urlGetDocuments parameter for remote settings
 * @param remoteSettingsAdd additional/optional config properties to be added into <code>remote</code> configuration
 *          node
 * @param toplevelSettingsAdd additional/optional config properties to be added into toplevel node. Do not add
 *          <code>remote</code> here, will be ignored.
 * @param initRemoteClientMock if set to true then Mockito mock instance is created and set into
 *          {@link RemoteRiver#remoteSystemClient}
 * @return instance for tests
 * @throws Exception from constructor
 */
public static RemoteRiver prepareRiverInstanceForTest(String urlGetDocuments, Map<String, Object> remoteSettingsAdd,
		Map<String, Object> toplevelSettingsAdd, boolean initRemoteClientMock) throws Exception {
	Map<String, Object> settings = new HashMap<String, Object>();
	if (toplevelSettingsAdd != null)
		settings.putAll(toplevelSettingsAdd);
	if (urlGetDocuments != null || remoteSettingsAdd != null) {
		Map<String, Object> remoteSettings = new HashMap<String, Object>();
		settings.put("remote", remoteSettings);
		if (remoteSettingsAdd != null)
			remoteSettings.putAll(remoteSettingsAdd);
		remoteSettings.put(GetJSONClient.CFG_URL_GET_DOCUMENTS, urlGetDocuments);
		remoteSettings.put(GetJSONClient.CFG_URL_GET_SPACES, urlGetDocuments);
	}

	Settings gs = mock(Settings.class);
	RiverSettings rs = new RiverSettings(gs, settings);
	Client clientMock = mock(Client.class);
	RemoteRiver tested = new RemoteRiver(new RiverName("remote", RIVER_NAME), rs, clientMock);
	if (initRemoteClientMock) {
		IRemoteSystemClient remoteClientMock = mock(IRemoteSystemClient.class);
		tested.remoteSystemClient = remoteClientMock;
	}
	return tested;
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
@Inject
public ZookeeperRiver(final RiverName riverName, final RiverSettings settings,
        final Client client) {
    super(riverName, settings);
    this.client = client;

    logger.info("CREATE ZookeeperRiver");

    // TODO Your code..

}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
@SuppressWarnings({"unchecked"})
@Inject
public GitHubRiver(RiverName riverName, RiverSettings settings, Client client) {
    super(riverName, settings);
    this.client = client;

    if (!settings.settings().containsKey("github")) {
        throw new IllegalArgumentException("Need river settings - owner and repository.");
    }

    // get settings
    Map<String, Object> githubSettings = (Map<String, Object>) settings.settings().get("github");
    owner = XContentMapValues.nodeStringValue(githubSettings.get("owner"), null);
    repository = XContentMapValues.nodeStringValue(githubSettings.get("repository"), null);

    index = String.format("%s&%s", owner, repository);
    userRequestedInterval = XContentMapValues.nodeIntegerValue(githubSettings.get("interval"), 60);

    // auth (optional)
    username = null;
    password = null;
    if (githubSettings.containsKey("authentication")) {
        Map<String, Object> auth = (Map<String, Object>) githubSettings.get("authentication");
        username = XContentMapValues.nodeStringValue(auth.get("username"), null);
        password = XContentMapValues.nodeStringValue(auth.get("password"), null);
    }

    // endpoint (optional - default to github.com)
    endpoint = XContentMapValues.nodeStringValue(githubSettings.get("endpoint"), "https://api.github.com");

    logger.info("Created GitHub river.");
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
@Inject
@SuppressWarnings({"unchecked"})
public JDBCRiver(RiverName riverName, RiverSettings riverSettings, Client client) {
    super(riverName, riverSettings);
    if (!riverSettings.settings().containsKey("jdbc")) {
        throw new IllegalArgumentException("no 'jdbc' settings in river settings?");
    }
    this.client = client;
    this.feeder = createFeeder(riverName.getType(), riverName.getName(), riverSettings);
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
private void setContextSettings(String riverResource) throws IOException {
    RiverSettings riverSettings = riverSettings(riverResource);
    Map<String, Object> settings = (Map<String, Object>) riverSettings.settings().get("jdbc");

    riverSettings.settings().put(ColumnRiverFlow.LAST_RUN_TIME, LAST_RUN_TIME);
    riverSettings.settings().put(ColumnRiverFlow.CURRENT_RUN_STARTED_TIME, new TimeValue(new Date().getTime()));

    context.setRiverSettings(riverSettings.settings());
    context.setStatements(SQLCommand.parse(settings));
    context.columnCreatedAt(XContentMapValues.nodeStringValue(settings.get("column_created_at"), null));
    context.columnUpdatedAt(XContentMapValues.nodeStringValue(settings.get("column_updated_at"), null));
    context.columnDeletedAt(XContentMapValues.nodeStringValue(settings.get("column_deleted_at"), null));
    context.columnEscape(true);
    context.setLastRunTimeStampOverlap(getLastRunTimestampOverlap(riverSettings));
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
private TimeValue getLastRunTimestampOverlap(RiverSettings riverSettings) {
    TimeValue overlap = TimeValue.timeValueMillis(0);
    Map<String, Object> jdbcSettingsMap = ((Map<String, Object>) (riverSettings.settings().get("jdbc")));
    if (jdbcSettingsMap != null && jdbcSettingsMap.containsKey("last_run_timestamp_overlap")) {
        overlap = XContentMapValues.nodeTimeValue(jdbcSettingsMap.get("last_run_timestamp_overlap"));
    }
    return overlap;
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
private void setupContext(RiverSource riverSource, String riverResource) throws IOException {
    RiverSettings riverSettings = riverSettings(riverResource);
    context.setRiverName(new RiverName(index, type).getName());
    context.setRiverMouth(new MockRiverMouth());
    context.setRiverSource(riverSource);
    context.setRiverSettings(riverSettings.settings());
    context.columnEscape(true);
}
 

import org.elasticsearch.river.RiverSettings; //导入依赖的package包/类
@Inject
  public KafkaRiver(RiverName riverName, RiverSettings settings, Client client) {
      super(riverName, settings);
      this.client = client;
      
      try {
	logger.info("KafkaRiver created: name={}, type={}", riverName.getName(), riverName.getType());
	this.riverConfig = new KafkaRiverConfig(settings);
} catch (Exception e) {
	logger.error("Unexpected Error occurred", e);
	throw new RuntimeException(e);
}
  }