@BeforeClass public void setup() throws Exception { TableDataManagerProvider.setServerMetrics(new ServerMetrics(new MetricsRegistry())); File confDir = new File(QueryExecutorTest.class.getClassLoader().getResource("conf").toURI()); setupSegmentList(2); // ServerBuilder serverBuilder = new ServerBuilder(confDir.getAbsolutePath()); String configFilePath = confDir.getAbsolutePath(); // build _serverConf PropertiesConfiguration serverConf = new PropertiesConfiguration(); serverConf.setDelimiterParsingDisabled(false); serverConf.load(new File(configFilePath, PINOT_PROPERTIES)); FileBasedInstanceDataManager instanceDataManager = FileBasedInstanceDataManager.getInstanceDataManager(); instanceDataManager.init( new FileBasedInstanceDataManagerConfig(serverConf.subset("pinot.server.instance"))); instanceDataManager.start(); for (int i = 0; i < 2; ++i) { instanceDataManager.getTableDataManager("midas"); instanceDataManager.getTableDataManager("midas").addSegment(_indexSegmentList.get(i)); } _queryExecutor = new ServerQueryExecutorV1Impl(); _queryExecutor.init( serverConf.subset("pinot.server.query.executor"), instanceDataManager, new ServerMetrics(new MetricsRegistry())); }
private static void showStartupInfo( PropertiesConfiguration buildConfiguration, boolean enableTLS, int appPort) { StringBuilder buffer = new StringBuilder(); buffer.append("\n############################################"); buffer.append("############################################"); buffer.append("\n Atlas Server (STARTUP)"); buffer.append("\n"); try { final Iterator<String> keys = buildConfiguration.getKeys(); while (keys.hasNext()) { String key = keys.next(); buffer .append('\n') .append('\t') .append(key) .append(":\t") .append(buildConfiguration.getProperty(key)); } } catch (Throwable e) { buffer.append("*** Unable to get build info ***"); } buffer.append("\n############################################"); buffer.append("############################################"); LOG.info(buffer.toString()); LOG.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"); LOG.info("Server starting with TLS ? {} on port {}", enableTLS, appPort); LOG.info("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"); }
/** Load the config parameters from fortress.properties file. */ private void loadLocalConfig() { try { // Load the system config file. URL fUrl = Config.class.getClassLoader().getResource(PROP_FILE); config.setDelimiterParsingDisabled(true); if (fUrl == null) { String error = "static init: Error, null cfg file: " + PROP_FILE; LOG.warn(error); } else { LOG.info("static init: found from: {} path: {}", PROP_FILE, fUrl.getPath()); config.load(fUrl); LOG.info("static init: loading from: {}", PROP_FILE); } URL fUserUrl = Config.class.getClassLoader().getResource(USER_PROP_FILE); if (fUserUrl != null) { LOG.info( "static init: found user properties from: {} path: {}", USER_PROP_FILE, fUserUrl.getPath()); config.load(fUserUrl); } } catch (org.apache.commons.configuration.ConfigurationException ex) { String error = "static init: Error loading from cfg file: [" + PROP_FILE + "] ConfigurationException=" + ex; LOG.error(error); throw new CfgRuntimeException(GlobalErrIds.FT_CONFIG_BOOTSTRAP_FAILED, error, ex); } }
public static void persistSSLClientConfiguration(PropertiesConfiguration clientConfig) throws AtlasException, IOException { // trust settings Configuration configuration = new Configuration(false); File sslClientFile = getSSLClientFile(); if (!sslClientFile.exists()) { configuration.set("ssl.client.truststore.type", "jks"); configuration.set( "ssl.client.truststore.location", clientConfig.getString(TRUSTSTORE_FILE_KEY)); if (clientConfig.getBoolean(CLIENT_AUTH_KEY, false)) { // need to get client key properties configuration.set( "ssl.client.keystore.location", clientConfig.getString(KEYSTORE_FILE_KEY)); configuration.set("ssl.client.keystore.type", "jks"); } // add the configured credential provider configuration.set( CredentialProviderFactory.CREDENTIAL_PROVIDER_PATH, clientConfig.getString(CERT_STORES_CREDENTIAL_PROVIDER_PATH)); String hostnameVerifier = clientConfig.getString(SSLFactory.SSL_HOSTNAME_VERIFIER_KEY); if (hostnameVerifier != null) { configuration.set(SSLFactory.SSL_HOSTNAME_VERIFIER_KEY, hostnameVerifier); } configuration.writeXml(new FileWriter(sslClientFile)); } }
public SenseiServerBuilder(File confDir, Map<String, Object> properties) throws Exception { if (properties != null) { _senseiConfFile = null; _senseiConf = new MapConfiguration(properties); ((MapConfiguration) _senseiConf).setDelimiterParsingDisabled(true); } else { _senseiConfFile = new File(confDir, SENSEI_PROPERTIES); if (!_senseiConfFile.exists()) { throw new ConfigurationException( "configuration file: " + _senseiConfFile.getAbsolutePath() + " does not exist."); } _senseiConf = new PropertiesConfiguration(); ((PropertiesConfiguration) _senseiConf).setDelimiterParsingDisabled(true); ((PropertiesConfiguration) _senseiConf).load(_senseiConfFile); } pluginRegistry = SenseiPluginRegistry.build(_senseiConf); pluginRegistry.start(); processRelevanceFunctionPlugins(pluginRegistry); processRelevanceExternalObjectPlugins(pluginRegistry); _gateway = pluginRegistry.getBeanByFullPrefix(SENSEI_GATEWAY, SenseiGateway.class); _schemaDoc = loadSchema(confDir); _senseiSchema = SenseiSchema.build(_schemaDoc); }
public static Configuration instance() { if (config == null) { try { // Default values build into war file, this is last prio used if no of the other sources // override this boolean allowexternal = Boolean.getBoolean( new PropertiesConfiguration( ExtraConfiguration.class.getResource("/" + PROPERTY_FILENAME)) .getString(CONFIGALLOWEXTERNAL, "false")); config = new CompositeConfiguration(); PropertiesConfiguration pc; // Only add these config sources if we allow external configuration if (allowexternal) { // Override with system properties, this is prio 1 if it exists (java -Dscep.test=foo) config.addConfiguration(new SystemConfiguration()); log.info("Added system properties to configuration source (java -Dfoo.prop=bar)."); // Override with file in "application server home directory"/conf, this is prio 2 File f1 = new File("conf/" + PROPERTY_FILENAME); pc = new PropertiesConfiguration(f1); pc.setReloadingStrategy(new FileChangedReloadingStrategy()); config.addConfiguration(pc); log.info("Added file to configuration source: " + f1.getAbsolutePath()); // Override with file in "/etc/ejbca/conf/extra, this is prio 3 File f2 = new File("/etc/ejbca/conf/extra/" + PROPERTY_FILENAME); pc = new PropertiesConfiguration(f2); pc.setReloadingStrategy(new FileChangedReloadingStrategy()); config.addConfiguration(pc); log.info("Added file to configuration source: " + f2.getAbsolutePath()); } // Default values build into war file, this is last prio used if no of the other sources // override this URL url = ExtraConfiguration.class.getResource("/" + PROPERTY_FILENAME); pc = new PropertiesConfiguration(url); config.addConfiguration(pc); log.info("Added url to configuration source: " + url); log.info("Allow external re-configuration: " + allowexternal); // Test log.debug("Using keystore path (1): " + config.getString(SCEPKEYSTOREPATH + ".1")); // log.debug("Using keystore pwd (1): "+config.getString(SCEPKEYSTOREPWD+".1")); // log.debug("Using authPwd: "+config.getString(SCEPAUTHPWD)); log.debug("Using certificate profile: " + config.getString(SCEPCERTPROFILEKEY)); log.debug("Using entity profile: " + config.getString(SCEPENTITYPROFILEKEY)); log.debug("Using default CA: " + config.getString(SCEPDEFAULTCA)); log.debug("Create or edit user: "******"Mapping for CN=Scep CA,O=EJBCA Sample,C=SE: " + config.getString("CN=Scep CA,O=EJBCA Sample,C=SE")); } catch (ConfigurationException e) { log.error("Error intializing ExtRA Configuration: ", e); } } return config; }
private static Project newProject(String key, String language) { PropertiesConfiguration configuration = new PropertiesConfiguration(); configuration.setProperty("sonar.language", language); return new Project(key) .setConfiguration(configuration) .setAnalysisType(Project.AnalysisType.DYNAMIC); }
/** * Converts the properties object into a JSON string. * * @param properties The properties object to convert. * @param envelope Envelope for resulting JSON object. Null if not needed. * @return A JSON string representing the object. */ public static String toJson(PropertiesConfiguration properties, String envelope) { JsonObject json = new JsonObject(); Iterator<String> i = properties.getKeys(); while (i.hasNext()) { final String key = i.next(); final String value = properties.getString(key); if (value.equals("true") || value.equals("false")) { json.addProperty(key.toString(), Boolean.parseBoolean(value)); } else if (PATTERN_INTEGER.matcher(value).matches()) { json.addProperty(key.toString(), Integer.parseInt(value)); } else if (PATTERN_FLOAT.matcher(value).matches()) { json.addProperty(key.toString(), Float.parseFloat(value)); } else { json.addProperty(key.toString(), value); } } GsonBuilder gsonBuilder = new GsonBuilder().disableHtmlEscaping(); Gson gson = gsonBuilder.create(); String _json = gson.toJson(json); if (envelope != null && !envelope.isEmpty()) { _json = envelope(_json, envelope); } return _json; }
@BeforeClass public void setup() throws Exception { CONFIG_BUILDER = new TestingServerPropertiesBuilder("testTable"); setupSegmentFor("testTable"); setUpTestQueries("testTable"); final PropertiesConfiguration serverConf = CONFIG_BUILDER.build(); serverConf.setDelimiterParsingDisabled(false); final FileBasedInstanceDataManager instanceDataManager = FileBasedInstanceDataManager.getInstanceDataManager(); instanceDataManager.init( new FileBasedInstanceDataManagerConfig(serverConf.subset("pinot.server.instance"))); instanceDataManager.start(); System.out.println( "************************** : " + new File(INDEX_DIR, "segment").getAbsolutePath()); File segmentFile = new File(INDEX_DIR, "segment").listFiles()[0]; segmentName = segmentFile.getName(); final IndexSegment indexSegment = ColumnarSegmentLoader.load(segmentFile, ReadMode.heap); instanceDataManager.getTableDataManager("testTable"); instanceDataManager.getTableDataManager("testTable").addSegment(indexSegment); QUERY_EXECUTOR = new ServerQueryExecutorV1Impl(false); QUERY_EXECUTOR.init( serverConf.subset("pinot.server.query.executor"), instanceDataManager, new ServerMetrics(new MetricsRegistry())); }
public static void setProperties(PropertiesConfiguration configuration) { configuration.getProperty(""); getMailProperties() .setMailLogin(configuration.getString(MailProperties.getMailType() + ".login")); getMailProperties() .setMailPass(configuration.getString(MailProperties.getMailType() + ".password")); getMailProperties().setMailUrl(configuration.getString(MailProperties.getMailType() + ".url")); }
@Test public void shouldGetPropertyValue() { PropertiesConfiguration conf = new PropertiesConfiguration(); conf.setProperty("sonar.timemachine.period1", "5"); assertThat(PastSnapshotFinder.getPropertyValue(conf, 1), is("5")); assertThat(PastSnapshotFinder.getPropertyValue(conf, 999), nullValue()); }
/** * Get an SQL statement for the appropriate vendor from the bundle * * @param key * @return statement or null if none found. */ private String getStatement(String key) { try { return statements.getString(key); } catch (NoSuchElementException e) { log.error("Statement: '" + key + "' could not be found in: " + statements.getFileName(), e); return null; } }
/** * Sets a property to rhqctl.properties. Note that calling this will eventually cause * rhqctl.properties file to be created later. * * @param key * @param value */ private void putProperty(String key, String value) { if (rhqctlConfig == null) { rhqctlConfig = new PropertiesConfiguration(); rhqctlConfig.setPath(getRhqCtlPropertiesPath()); } rhqctlConfig.setProperty(key, value); }
public void save() { if (properties != null) { try { properties.save(); } catch (ConfigurationException e) { logger.error("Coud not save properties on " + properties.getFileName()); } } }
@Test public void shouldGetDefaultPropertyValue() { PropertiesConfiguration conf = new PropertiesConfiguration(); conf.setProperty("sonar.timemachine.period1", "5"); assertThat( PastSnapshotFinder.getPropertyValue(conf, 2), is(CoreProperties.TIMEMACHINE_DEFAULT_PERIOD_2)); }
@Test public void hasJavaSourceFiles() { final DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project); assertThat(fs.hasJavaSourceFiles(), is(true)); PropertiesConfiguration conf = new PropertiesConfiguration(); conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "**/*.java"); project.setConfiguration(conf); assertThat(fs.hasJavaSourceFiles(), is(false)); }
@Test public void doNotApplyExclusionPatternsToTestFiles() { PropertiesConfiguration conf = new PropertiesConfiguration(); conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "**/B*.java"); project.setConfiguration(conf); final DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project); assertThat(fs.getTestFiles(Java.INSTANCE).size(), is(1)); assertThat(fs.getTestFiles(Java.INSTANCE), hasItem(named("BarTest.java"))); }
@Test public void applyExclusionPatternsToSourceFiles() { PropertiesConfiguration conf = new PropertiesConfiguration(); conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "**/B*.java"); project.setConfiguration(conf); final DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project); assertThat(fs.getJavaSourceFiles().size(), is(1)); assertThat(fs.getJavaSourceFiles(), hasItem(named("Whizz.java"))); }
@Override public void updateConfiguration(PropertiesConfiguration configuration) { if (configuration.getProperty("database").equals("derby")) { String url = (String) configuration.getProperty("database.url"); if (!StringUtils.contains(url, ";upgrade=")) { url += ";upgrade=true"; } configuration.setProperty("database.url", url); } }
/** See http://jira.codehaus.org/browse/SONAR-1449 */ @Test public void exclusionPatternOnAjFiles() { PropertiesConfiguration conf = new PropertiesConfiguration(); conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "**/*.aj"); project.setConfiguration(conf); final DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project); assertThat(fs.getSourceFiles(Java.INSTANCE).size(), is(2)); assertThat(fs.getSourceFiles(Java.INSTANCE), hasItem(named("Whizz.java"))); assertThat(fs.getSourceFiles(Java.INSTANCE), hasItem(named("Bar.java"))); }
// Saves the settings to config file. public static void saveSettings(Settings settings) { config.setProperty("vlclocation", settings.getVlcLocation()); config.setProperty("thumbnailcount", settings.getThumbnailCount()); config.setProperty("thumbnailwidth", settings.getThumbnailWidth()); config.setProperty("thumbnailhighlightcolor", settings.getThumbnailHighlightColor()); config.setProperty("folders", String.join("|", settings.getFolders())); try { config.save("vidor.config"); } catch (ConfigurationException ex) { ex.printStackTrace(); } }
@Override public SystemConfiguration getSystemConfiguration() { // Create a new SystemConfiguration by reading out the parameters in the config file logger.trace("Loading System Configuration"); SystemConfiguration systemConfiguration = new SystemConfiguration(); systemConfiguration.setThreadPoolSize( propertiesConfiguration.getInt(PropertiesConfigurationEntries.THREAD_POOL_SIZE)); systemConfiguration.setDaemonThreadTimer( propertiesConfiguration.getInt(PropertiesConfigurationEntries.SYSTEM_DAEMON_TIMER)); return systemConfiguration; }
/** * Converts a JSON string into the properties object. * * @param properties The properties object to convert. * @return A JSON string representing the object. Null if conversion fails. */ public static PropertiesConfiguration toProperties(String json) { try { Properties src = JsonPropertiesConverter.toProperties(json); if (src != null) { PropertiesConfiguration dest = new PropertiesConfiguration(); for (String key : src.stringPropertyNames()) { dest.setProperty(key, src.getProperty(key)); } return dest; } } catch (Exception e) { } return null; }
@Override public void initliaze(InputStream input, WebApplicationConfiguration configuration) throws Exception { PropertiesConfiguration pc = new PropertiesConfiguration(); pc.load(input); BeanUtilsBean bu = retrieveBeanUtilsBean(); Iterator<String> keys = pc.getKeys(); while (keys.hasNext()) { String key = keys.next(); String value = pc.getString(key); fillConfiguration(configuration, bu, key, value); } }
private static org.apache.commons.configuration.Configuration init() { PropertiesConfiguration config = null; try { config = new PropertiesConfiguration(); config.setListDelimiter('\0'); config.load(ERR_CODE_FILE); } catch (ConfigurationException ex) { // error out if the configuration file is not there String message = "Failed to load serengeti error message file."; Logger.getLogger(RestResource.class).fatal(message, ex); throw BddException.APP_INIT_ERROR(ex, message); } return config; }
public UserStore(String nombre, PropertiesConfiguration configuration) { BasicDataSource ds = null; String driver = configuration.getString("userstore.driver"); if (driver != null) { ds = new BasicDataSource(); ds.setDriverClassName(driver); ds.setUrl(configuration.getString("userstore.url")); ds.setUsername(configuration.getString("userstore.username")); ds.setPassword(configuration.getString("userstore.password")); ds.setMaxActive(configuration.getInt("userstore.maxActive")); ds.setMinIdle(configuration.getInt("userstore.minIdle")); ds.setMaxWait(configuration.getInt("userstore.maxWait")); } this.dataSource = ds; System.out.println(ds); this.selectUser = configuration.getString("userstore.selectUser"); this.encoding = configuration.getString("userstore.encoding"); String algorithm = configuration.getString("userstore.algorithm"); if (algorithm != null && !algorithm.isEmpty()) { try { messageDigest = MessageDigest.getInstance(algorithm); } catch (NoSuchAlgorithmException algorithmException) { System.out.println( "Algoritmo " + algorithm + "no encontrado... no se cifrararan los passwords"); messageDigest = null; } this.nombre = nombre; } }
@Override public BluetoothConfiguration getBluetoothConfiguration() { // Create a new BluetoothConfiguration by reading out the parameters in the config file logger.trace("Loading Bluetooth Configuration"); BluetoothConfiguration bluetoothConfiguration = new BluetoothConfiguration(); bluetoothConfiguration.setServerName( propertiesConfiguration.getString(PropertiesConfigurationEntries.BLUETOOTH_SERVER)); bluetoothConfiguration.setServiceName( propertiesConfiguration.getString(PropertiesConfigurationEntries.BLUETOOTH_SERVICE)); bluetoothConfiguration.setServiceUUID( propertiesConfiguration.getString(PropertiesConfigurationEntries.BLUETOOTH_UUID)); return bluetoothConfiguration; }
/** @see Plugin#init() */ public void init() throws PluginException { try { if (System.getProperty("roda.home") != null) { RODA_HOME = System.getProperty("roda.home"); } else if (System.getenv("RODA_HOME") != null) { RODA_HOME = System.getenv("RODA_HOME"); } else { RODA_HOME = null; } if (StringUtils.isBlank(RODA_HOME)) { throw new PluginException( "RODA_HOME enviroment variable and ${roda.home} system property are not set."); } final File pluginsConfigDirectory = new File(new File(RODA_HOME, "config"), "plugins"); final File configFile = new File(pluginsConfigDirectory, CONFIGURATION_FILENAME); final PropertiesConfiguration configuration = new PropertiesConfiguration(); if (configFile.isFile()) { configuration.load(configFile); logger.info("Loading configuration file from " + configFile); } else { configuration.load(getClass().getResourceAsStream("/" + CONFIGURATION_FILENAME)); logger.info("Loading default configuration file from resources"); } taverna_bin = configuration.getString("taverna_bin"); logger.debug("taverna_bin=" + taverna_bin); xpathSelectIDs = configuration.getString("xpathSelectIDs"); logger.debug("xpathSelectIDs=" + xpathSelectIDs); xpathSelectWorkflow = configuration.getString("xpathSelectWorkflow"); logger.debug("xpathSelectWorkflow=" + xpathSelectWorkflow); workflowInputPort = configuration.getString("workflowInputPort"); logger.debug("workflowInputPort=" + workflowInputPort); workflowOutputPort = configuration.getString("workflowOutputPort"); logger.debug("workflowOutputPort=" + workflowOutputPort); workflowExtraPorts = configuration.getStringArray("workflowExtraPorts"); logger.debug("workflowExtraPorts=" + Arrays.asList(workflowExtraPorts)); } catch (ConfigurationException ex) { logger.debug("Error reading plugin configuration - " + ex.getMessage(), ex); throw new PluginException("Error reading plugin configuration - " + ex.getMessage(), ex); } planFile = new File(new File(RODA_HOME, "data"), PLAN_FILENAME); logger.debug("init() OK"); }
public int exec(String[] args) { Options options = getOptions(); int rValue = RHQControl.EXIT_CODE_OK; try { CommandLineParser parser = new RHQPosixParser(false); CommandLine cmdLine = parser.parse(options, args, true); if (!cmdLine.getArgList().isEmpty()) { // there were some unrecognized args System.out.println("Unrecognized arguments: " + cmdLine.getArgList()); printUsage(); return RHQControl.EXIT_CODE_INVALID_ARGUMENT; } rValue = exec(cmdLine); if (rhqctlConfig != null) { rhqctlConfig.save(); } } catch (ParseException e) { printUsage(); rValue = RHQControl.EXIT_CODE_INVALID_ARGUMENT; } catch (ConfigurationException e) { throw new RHQControlException("Failed to update " + getRhqCtlProperties(), e); } return rValue; }
static void saveConfiguration() { try { configuration.save(); } catch (ConfigurationException ce) { log.error("Could not save Configuration.", ce); } }