private static void initializeHystrixSettings() {
   hystrixConfig = ConfigurationManager.getConfigInstance();
   hystrixConfig.setProperty(CORE_SIZE_CONFIG, "20");
   hystrixConfig.setProperty(MAX_QUEUE_SIZE_CONFIG, "20");
   hystrixConfig.setProperty(QUEUE_REJECTION_THRESHOLD_CONFIG, "10");
   hystrixConfig.setProperty(COLLAPSER_TIMER_DELAY, "50");
 }
Exemple #2
0
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
     throws IOException, ServletException {
   AbstractConfiguration conf = WebConfig.getConfig();
   for (Iterator<String> it = conf.getKeys(); it.hasNext(); ) {
     String key = it.next();
     String value = conf.getString(key);
     request.setAttribute(key, value);
   }
   chain.doFilter(request, response);
 }
  @Before
  public void setUp() {
    AbstractConfiguration.setDefaultListDelimiter(',');
    clearSystemProperties();
    this.configurationHelper = new ConfigurationHelper();
    this.test1Properties =
        new HashMap<String, String>() {
          {
            this.put("a.b.c", "efgh");
            this.put("a.b.d", "1234");
          }
        };

    this.test3Properties =
        new HashMap<String, String>() {
          {
            this.put("a.b.c", "jklm");
            this.put("e.f.h", "90123");
            // The value in the file is "foo,bar" but AbstractConfiguration.getString(key) only
            // returns
            // the first item in a collection.
            this.put("i.j.k", "foo");
          }
        };
  }
  @Test
  public void testFromSystem_containsListValues() throws Exception {
    AbstractConfiguration.setDefaultListDelimiter('|');
    Map<String, String> properties = Maps.newHashMap();
    properties.put("testProperty", "b,bee");

    for (Entry<String, String> entry : properties.entrySet()) {
      System.setProperty(entry.getKey(), entry.getValue());
    }

    Splitter splitter = Splitter.on(',');
    Configuration systemConfiguration = configurationHelper.fromSystem();
    for (Entry<String, String> entry : properties.entrySet()) {
      String[] actualValues = systemConfiguration.getStringArray(entry.getKey());
      String[] expectedValues;
      if ("line.separator".equals(entry.getKey())) {
        expectedValues = new String[] {SystemUtils.LINE_SEPARATOR};
      } else {
        expectedValues = splitter.splitToList(entry.getValue()).toArray(new String[0]);
      }
      assertArrayEquals(
          String.format("Values for key %s do not match", entry.getKey()),
          expectedValues,
          actualValues);
    }
  }
 /**
  * Asserts that reading list values from a properties file works properly when the default list
  * delimiter is modified.
  */
 @Test
 public void testFromFile_listValuesWithDefaultDelimiterChanged() throws Exception {
   AbstractConfiguration.setDefaultListDelimiter('|');
   Configuration configuration =
       configurationHelper.fromFile(
           ConfigurationHelperTest.class.getResource("props/test3.properties"));
   assertPropertiesEquals(test3Properties, configuration);
   String[] stringArray = configuration.getStringArray("i.j.k");
   assertArrayEquals(new String[] {"foo", "bar"}, stringArray);
 }
  @Test
  public void testDataStorage()
      throws IllegalDataStorageTypeException, IllegalDataStorageException {
    DataStorage dataStorage = DataStorageManager.newDataStorage("test");
    assert dataStorage instanceof TestDataStorage;

    // get eagle.storage.type (value: test) from src/test/resources/config.properties
    DataStorage dataStorage2 = DataStorageManager.getDataStorageByEagleConfig();
    assert dataStorage2 instanceof TestDataStorage;

    AbstractConfiguration configuration = new CombinedConfiguration();
    configuration.addProperty(DataStorageManager.EAGLE_STORAGE_TYPE, "test");
    DataStorage dataStorage3 = DataStorageManager.newDataStorage(configuration);
    assert dataStorage3 instanceof TestDataStorage;

    Properties properties = new Properties();
    properties.put(DataStorageManager.EAGLE_STORAGE_TYPE, "test");
    DataStorage dataStorage4 = DataStorageManager.newDataStorage(properties);
    assert dataStorage4 instanceof TestDataStorage;
  }
 public static void addApplicationContext(ConfigurableApplicationContext context) {
   AbstractConfiguration config = ConfigurationManager.getConfigInstance();
   config.clearProperty(APPLICATION_CONTEXT);
   config.setProperty(APPLICATION_CONTEXT, context);
 }
  public void processQueries(String instanceName, String xmlFile) {

    XMLConfiguration config = null;
    /** clear'em out */
    if (collectionQueries.get(instanceName) != null) {
      collectionQueries.get(instanceName).clear();
    }
    if (relationshipQueries.get(instanceName) != null) {
      relationshipQueries.get(instanceName).clear();
    }

    if (jdbcDriver != null) {
      jdbcDriver = null;
    }

    if (validationQuery != null) {
      validationQuery = null;
    }

    if (url != null) {
      url = null;
    }

    try {
      /**
       * use strange ethiopic unicode character so that it never delimits the properties
       *
       * <p>This is a workaround becuase config.setDelimiterParsingDisabled(true) doesn't disable
       * parsing
       */
      AbstractConfiguration.setDefaultListDelimiter('\u12BF');
      config = new XMLConfiguration(xmlFile);
      config.setDelimiterParsingDisabled(true);
      Map<String, String> instanceCollectionQueryMap = new TreeMap<String, String>();
      Map<String, String> instanceRelationshipQueryMap = new TreeMap<String, String>();
      Map<String, String> instanceAttributeQueryMap = new TreeMap<String, String>();

      @SuppressWarnings("unchecked")
      List<HierarchicalConfiguration> params = config.configurationsAt("configuration");
      for (HierarchicalConfiguration param : params) {
        this.jdbcDriver = param.getString("driver");
        this.validationQuery = param.getString("validationquery");
        this.url = param.getString("url");
        this.cycleTimeOffset = param.getInt("cycletimeoffset");
        if (log.isDebugEnabled()) {
          log.debug("jdbcDriver:" + param.getString("driver"));
          log.debug("validationQuery:" + param.getString("validationquery"));
          log.debug("url:" + param.getString("url"));
          log.debug("cycleTimeOffset:" + param.getInt("cycletimeoffset"));
        }
      }

      @SuppressWarnings("unchecked")
      List<HierarchicalConfiguration> queries = config.configurationsAt("queries.query");
      for (HierarchicalConfiguration sub : queries) {
        String name = sub.getString("name");
        String type = sub.getString("type");
        String sql = sub.getString("sql");

        if (type.equalsIgnoreCase("collection")) {
          instanceCollectionQueryMap.put(name, sql);
        } else if (type.equalsIgnoreCase("relationship")) {
          instanceRelationshipQueryMap.put(name, sql);
        } else if (type.equalsIgnoreCase("attribute")) {
          instanceAttributeQueryMap.put(name, sql);
        }
      }

      collectionQueries.put(instanceName, instanceCollectionQueryMap);
      relationshipQueries.put(instanceName, instanceRelationshipQueryMap);
      attributeQueries.put(instanceName, instanceAttributeQueryMap);

    } catch (ConfigurationException e) {
      log.error(e);
    }
  }