Exemplo n.º 1
0
 public void testTranslationKeyExistence() throws IOException {
   // use English version as the reference:
   final File englishFile = getEnglishTranslationFile();
   final Properties enProps = new Properties();
   enProps.load(new FileInputStream(englishFile));
   final Set<Object> englishKeys = enProps.keySet();
   for (Language lang : Language.REAL_LANGUAGES) {
     if (lang.getShortName().equals("en")) {
       continue;
     }
     final Properties langProps = new Properties();
     final File langFile = getTranslationFile(lang);
     if (!langFile.exists()) {
       continue;
     }
     try (FileInputStream stream = new FileInputStream(langFile)) {
       langProps.load(stream);
       final Set<Object> langKeys = langProps.keySet();
       for (Object englishKey : englishKeys) {
         if (!langKeys.contains(englishKey)) {
           System.err.println("***** No key '" + englishKey + "' in file " + langFile);
         }
       }
     }
   }
 }
Exemplo n.º 2
0
  /** This method is responsible for undeploying it. */
  public void unDeploy() throws EARException {
    try {
      Properties fileProperties = readProperties(filesPath);
      Properties contextProperties = readProperties(contextFilePath);

      // remove context entries
      for (Object key : contextProperties.keySet()) {
        String context = contextProperties.getProperty(key.toString());
        ContextClassLoaderLookup.getInstance().removeContext(context);
      }

      // remove files
      for (Object key : fileProperties.keySet()) {
        File file = new File(fileProperties.getProperty(key.toString()));
        file.delete();
      }

      // remove the configuration files
      filesPath.delete();
      contextFilePath.delete();

    } catch (Exception ex) {
      log.error("Failed to undeploy the ear because :" + ex.getMessage(), ex);
      throw new EARException("Failed to undeploy the ear because :" + ex.getMessage(), ex);
    }
  }
  // public SessionFactory newSessionFactory(Configuration config) throws HibernateException {
  public Configuration newConfiguration() throws HibernateException {
    Configuration config = super.newConfiguration();

    log.debug("Configuring hibernate sessionFactory properties");

    Properties moduleProperties = Context.getConfigProperties();

    // override or initialize config properties with module-provided ones
    for (Object key : moduleProperties.keySet()) {
      String prop = (String) key;
      String value = (String) moduleProperties.get(key);
      log.trace("Setting module property: " + prop + ":" + value);
      config.setProperty(prop, value);
      if (!prop.startsWith("hibernate")) config.setProperty("hibernate." + prop, value);
    }

    Properties properties = Context.getRuntimeProperties();

    // loop over runtime properties and override each in the configuration
    for (Object key : properties.keySet()) {
      String prop = (String) key;
      String value = (String) properties.get(key);
      log.trace("Setting property: " + prop + ":" + value);
      config.setProperty(prop, value);
      if (!prop.startsWith("hibernate")) config.setProperty("hibernate." + prop, value);
    }

    // load in the default hibernate properties
    try {
      InputStream propertyStream =
          ConfigHelper.getResourceAsStream("/hibernate.default.properties");
      Properties props = new Properties();
      OpenmrsUtil.loadProperties(props, propertyStream);
      propertyStream.close();

      // Only load in the default properties if they don't exist
      config.mergeProperties(props);
    } catch (IOException e) {
      log.fatal("Unable to load default hibernate properties", e);
    }

    log.debug(
        "Setting global Hibernate Session Interceptor for SessionFactory, Interceptor: "
            + chainingInterceptor);

    // make sure all autowired interceptors are put onto our chaining interceptor
    // sort on the keys so that the devs/modules have some sort of control over the order of the
    // interceptors
    List<String> keys = new ArrayList<String>(interceptors.keySet());
    Collections.sort(keys);
    for (String key : keys) {
      chainingInterceptor.addInterceptor(interceptors.get(key));
    }

    config.setInterceptor(chainingInterceptor);

    return config;
  }
Exemplo n.º 4
0
 private Properties merge(Properties include, Properties exclude) {
   Set<Object> in = new HashSet<Object>(include.keySet());
   in.addAll(exclude.keySet());
   Properties merged = new Properties();
   for (Object key : in) {
     if (include.containsKey(key)) {
       merged.put(key, include.get(key));
     } else if (exclude.containsKey(key)) {
       merged.put(key, exclude.get(key));
     }
   }
   return merged;
 }
 private void removeProperties(String propertiesFilePath, String... propertiesName) {
   if (propertiesName.length > 0) {
     Properties properties = CommandsUtils.readProperties(propertiesFilePath);
     if (properties != null && !properties.isEmpty()) {
       for (String propertieName : propertiesName) {
         if (properties.keySet().contains(propertieName)) {
           properties.remove(propertieName);
         }
       }
       FileOutputStream fos = null;
       try {
         fos = new FileOutputStream(propertiesFilePath);
         properties.store(fos, "");
       } catch (FileNotFoundException e) {
         // nothing to do
       } catch (IOException e) {
         // nothing to do
       } finally {
         if (fos != null) {
           try {
             fos.close();
           } catch (IOException e) {
             // nothing to do
           }
         }
       }
     }
   }
 }
  public Properties getDBPameterProperties(String connectionStr) {
    Properties paramProperties = new Properties();
    if (connectionStr != null) {
      String matchSubStr = connectionStr.substring(0, 8);
      Set<Object> s = PROP.keySet();
      Iterator<Object> it = s.iterator();
      while (it.hasNext()) {
        String id = (String) it.next();
        String value = PROP.getProperty(id);
        if (value.contains(matchSubStr)) {
          paramProperties.setProperty(PluginConstant.DBTYPE_PROPERTY, id);
          MessageFormat mf = new MessageFormat(value);
          Object[] parseResult = mf.parse(connectionStr, new ParsePosition(0));
          if (parseResult != null) {
            if (parseResult[0] != null) {
              paramProperties.setProperty(
                  PluginConstant.HOSTNAME_PROPERTY, (String) parseResult[0]);
            }

            if (parseResult[1] != null) {
              paramProperties.setProperty(PluginConstant.PORT_PROPERTY, (String) parseResult[1]);
            }

            break;
          }
        }
      }
    } else {
      paramProperties.setProperty(PluginConstant.DBTYPE_PROPERTY, "");
      paramProperties.setProperty(PluginConstant.HOSTNAME_PROPERTY, "");
      paramProperties.setProperty(PluginConstant.PORT_PROPERTY, "");
    }

    return paramProperties;
  }
Exemplo n.º 7
0
 /**
  * Return a list of resource model configuration
  *
  * @param props properties
  * @return List of Maps, each map containing "type": String, "props":Properties
  */
 public static List<Map<String, Object>> listResourceModelConfigurations(final Properties props) {
   final ArrayList<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
   int i = 1;
   boolean done = false;
   while (!done) {
     final String prefix = RESOURCES_SOURCE_PROP_PREFIX + "." + i;
     if (props.containsKey(prefix + ".type")) {
       final String providerType = props.getProperty(prefix + ".type");
       final Properties configProps = new Properties();
       final int len = (prefix + ".config.").length();
       for (final Object o : props.keySet()) {
         final String key = (String) o;
         if (key.startsWith(prefix + ".config.")) {
           configProps.setProperty(key.substring(len), props.getProperty(key));
         }
       }
       final HashMap<String, Object> map = new HashMap<String, Object>();
       map.put("type", providerType);
       map.put("props", configProps);
       list.add(map);
     } else {
       done = true;
     }
     i++;
   }
   return list;
 }
Exemplo n.º 8
0
  protected void registerFromProperties(Properties properties) {
    if (properties != null) {
      class2ElementRegistry.clear();
      //            for ( String keyOrClassName: properties.keySet() ) {
      for (Iterator iter = properties.keySet().iterator(); iter.hasNext(); ) {
        String keyOrClassName = (String) iter.next();
        String element = (String) properties.get(keyOrClassName);

        Object key = keyOrClassName;
        try {
          key = Class.forName(keyOrClassName);
        } catch (ClassNotFoundException e) {
        }
        if (handlerClass == null) {
          try {
            register(key, Class.forName(element));
          } catch (ClassNotFoundException e) {
            e.printStackTrace();
          }
        } else {
          register(key, element);
        }
      }
    }
  }
  private void initControls() {
    IConnectionProfile profile = getConnectionProfile();
    Properties props = profile.getBaseProperties();
    if (null != props.get(IWSProfileConstants.PARAMETER_MAP)
        & !props.get(IWSProfileConstants.PARAMETER_MAP).equals(StringUtilities.EMPTY_STRING)) {
      this.parameterMap = ((Map) props.get(IWSProfileConstants.PARAMETER_MAP));
    }
    if (null != props.get(ICredentialsCommon.USERNAME_PROP_ID)) {
      usernameText.setText((String) props.get(ICredentialsCommon.USERNAME_PROP_ID));
    }
    if (null != props.get(ICredentialsCommon.PASSWORD_PROP_ID)) {
      passwordText.setText((String) props.get(ICredentialsCommon.PASSWORD_PROP_ID));
    }
    String url = ConnectionInfoHelper.readEndPointProperty(props);
    if (null != url) {
      urlText.setText(url);
    }
    if (null != props.get(ICredentialsCommon.SECURITY_TYPE_ID)) {
      securityText.setText((String) props.get(ICredentialsCommon.SECURITY_TYPE_ID));
    }

    for (Object key : props.keySet()) {
      String keyStr = (String) key;
      if (ICredentialsCommon.PASSWORD_PROP_ID.equalsIgnoreCase(keyStr)
          || ICredentialsCommon.SECURITY_TYPE_ID.equalsIgnoreCase(keyStr)
          || ICredentialsCommon.USERNAME_PROP_ID.equalsIgnoreCase(keyStr)
          || IWSProfileConstants.END_POINT_URI_PROP_ID.equalsIgnoreCase(keyStr)) {
        // do nothing;
      } else {
        extraProperties.put(key, props.get(key));
      }
    }
  }
  protected Map<String, String> getMetadata(ZipReader zipReader) throws KBArticleImportException {

    InputStream inputStream = null;

    try {
      inputStream = zipReader.getEntryAsInputStream(".METADATA");

      if (inputStream == null) {
        return Collections.emptyMap();
      }

      Properties properties = new Properties();

      properties.load(inputStream);

      Map<String, String> metadata = new HashMap<String, String>(properties.size());

      for (Object key : properties.keySet()) {
        Object value = properties.get(key);

        if (value != null) {
          metadata.put(key.toString(), value.toString());
        }
      }

      return metadata;
    } catch (IOException ioe) {
      throw new KBArticleImportException(ioe);
    } finally {
      StreamUtil.cleanUp(inputStream);
    }
  }
Exemplo n.º 11
0
  private static DeviceMacReferenceMap readDeviceMacReferenceMap(final String fileName)
      throws IOException {

    final DeviceMacReferenceMap deviceMacReferenceMap;
    final File referenceToMacMapPropertiesFile = new File(fileName);

    if (!referenceToMacMapPropertiesFile.exists()) {
      log.error("Reference file {} does not exist!");
      System.exit(EXIT_CODE_REFERENCE_FILE_NOT_EXISTING);
    } else if (!referenceToMacMapPropertiesFile.canRead()) {
      log.error("Reference file {} is not readable!");
      System.exit(EXIT_CODE_REFERENCE_FILE_NOT_READABLE);
    } else if (referenceToMacMapPropertiesFile.isDirectory()) {
      log.error("Reference file {} is a directory!");
      System.exit(EXIT_CODE_REFERENCE_FILE_IS_DIRECTORY);
    }

    Properties properties = new Properties();
    properties.load(new FileInputStream(referenceToMacMapPropertiesFile));

    deviceMacReferenceMap = new DeviceMacReferenceMap();

    for (Object key : properties.keySet()) {
      final String value = (String) properties.get(key);
      deviceMacReferenceMap.put((String) key, new MacAddress(value));
    }

    return deviceMacReferenceMap;
  }
Exemplo n.º 12
0
  /** 读取配置文件中的全局参数的配置,存到缓存中 */
  private static void initProperties() {
    try {

      logger.debug("加载属性配置文件开始!");
      String propUrl = getSysPath() + "config.properties";
      logger.debug("系统全局参数的路径是:" + propUrl);
      FileInputStream fis = new FileInputStream(propUrl); // 属性文件流
      Properties prop = new Properties(); // 属性集合对象
      prop.load(fis); // 将属性文件流装载到Properties对象中
      logger.debug("属性的长度:" + prop.size());

      Map<String, String> paramMap = new HashMap<String, String>();
      Iterator<Object> it = prop.keySet().iterator();
      while (it.hasNext()) {
        String key = (String) (it.next());
        String value = prop.getProperty(key);
        logger.debug(key + "=" + value);
        // global.ip=192.168.0.242的格式
        // map.put(key, prop.getProperty(key));
        paramMap.put(key, value);
      }
      logger.debug("加载属性配置文件结束!");
      setConfigMap(paramMap);

    } catch (FileNotFoundException e) {
      logger.error("文件未找到!");
      e.printStackTrace();
    } catch (IOException e) {
      logger.error("读取文件的时候异常!");
      e.printStackTrace();
    } catch (Exception e) {
      logger.error("其它异常!");
      e.printStackTrace();
    }
  }
Exemplo n.º 13
0
 @SuppressWarnings("null")
 KernelPropertiesImpl() {
   final Properties sysProps = System.getProperties();
   final File propsFile =
       new File(sysProps.getProperty("ami.kernel.properties", "/etc/ami/kernel.properties"));
   configDir = propsFile.getParentFile();
   final Properties properties = new Properties();
   try {
     final FileReader reader = new FileReader(propsFile);
     try {
       properties.load(reader);
     } finally {
       reader.close();
     }
   } catch (final FileNotFoundException e) {
     throw new FoobarError("Kernel properties file (" + propsFile + ") not found", e);
   } catch (final IOException e) {
     throw new FoobarError("Unable to read kernel properties file (" + propsFile + ")", e);
   }
   final Map<String, String> map = new HashMap<String, String>();
   for (final Object key : properties.keySet()) {
     if (key instanceof String) {
       final Object value = properties.get(key);
       if (value instanceof String) map.put((String) key, (String) value);
     }
   }
   this.properties = Collections.unmodifiableMap(map);
 }
Exemplo n.º 14
0
  public static final void loadBuildingEnemiesData(Context c) {
    Properties props = DataStore.loadResources(c, ResourceUtil.getRID(R.raw.class, "bd_enemies"));

    Set<Object> keys = props.keySet();

    for (Object key : keys) {
      // Log.e("TTTT","TTTT key: " + key);
      String bd_id_lane[] = key.toString().split("-");
      if (bd_id_lane.length != 2) continue;

      String bd_id = bd_id_lane[0];
      int lane = Integer.parseInt(bd_id_lane[1]);

      String value = props.getProperty(key.toString());

      BuildingEnemiesData bed = new BuildingEnemiesData(bd_id, value);

      BuildingEnemiesData[] bd_enemies = buildingEnemiesDataMap.get(bd_id);
      if (bd_enemies == null) {
        bd_enemies = new BuildingEnemiesData[5];
        buildingEnemiesDataMap.put(bd_id, bd_enemies);
      }
      bd_enemies[lane] = bed;
    }
  }
  private void addPropertiesToProject(Project project) {
    Properties projectProperties = new Properties();
    File projectPropertiesFile = new File(project.getProjectDir(), Project.GRADLE_PROPERTIES);
    LOGGER.debug("Looking for project properties from: {}", projectPropertiesFile);
    if (projectPropertiesFile.isFile()) {
      projectProperties = GUtil.loadProperties(projectPropertiesFile);
      LOGGER.debug(
          "Adding project properties (if not overwritten by user properties): {}",
          projectProperties.keySet());
    } else {
      LOGGER.debug("project property file does not exists. We continue!");
    }

    Map<String, String> mergedProperties =
        propertiesLoader.mergeProperties(new HashMap(projectProperties));
    ExtraPropertiesExtension extraProperties =
        new DslObject(project).getExtensions().getExtraProperties();
    for (Map.Entry<String, String> entry : mergedProperties.entrySet()) {
      if (project.hasProperty(entry.getKey())) {
        project.setProperty(entry.getKey(), entry.getValue());
      } else {
        extraProperties.set(entry.getKey(), entry.getValue());
      }
    }
  }
  /*
   * (non-Javadoc)
   *
   * @see org.ow2.play.service.registry.api.Registry#load(java.lang.String)
   */
  @Override
  @WebMethod
  public void load(String url) throws RegistryException {
    if (logger.isLoggable(Level.FINE)) {
      logger.fine(String.format("Load from url %s", url));
    }

    if (url == null) {
      throw new RegistryException("Can not load properties from null value");
    }

    // This is the only time we initialize if not already done...
    if (!initialized) {
      init();
    }

    Properties props = new Properties();
    try {
      URL u = new URL(url);
      props.load(u.openStream());

      for (Object key : props.keySet()) {
        String k = key.toString();
        Object v = props.getProperty(k);
        if (v != null) {
          this.put(k, v.toString());
        }
      }

    } catch (Exception e) {
      logger.warning(e.getMessage());
      throw new RegistryException(e);
    }
  }
Exemplo n.º 17
0
  public static Map<String, Properties> loadDBConfig(Properties p) {
    Map<String, Properties> dbConfigs = Maps.newHashMapWithExpectedSize(1);
    for (Object o : p.keySet()) {
      String _key = String.valueOf(o);
      String value = p.getProperty(_key);

      if (StringUtils.startsWithIgnoreCase(_key, "db")) {
        int last_idx = _key.lastIndexOf(StringPool.DOT);
        if (last_idx > 2) {
          // like db.second.url
          String config_name = _key.substring(_key.indexOf(StringPool.DOT) + 1, last_idx);
          if (logger.isDebugEnabled()) {
            logger.debug("the db config is {}", config_name);
          }
          Properties db_config_props = dbConfigs.get(config_name);
          if (db_config_props == null) {
            db_config_props = new Properties();
            dbConfigs.put(config_name, db_config_props);
          }
          _key = _key.replace(StringPool.DOT + config_name, StringPool.EMPTY);
          db_config_props.put(_key, value);
        } else {
          Properties db_main_props = dbConfigs.get("main");
          if (db_main_props == null) {
            db_main_props = new Properties();
            dbConfigs.put("main", db_main_props);
          }
          db_main_props.put(_key, value);
        }
      }
    }
    return dbConfigs;
  }
Exemplo n.º 18
0
    public PropertyPanel(String title, Properties properties) {
      super();
      setBorder(new TitledBorder(BorderFactory.createEtchedBorder(), title));
      setLayout(new GridLayout(1, 1, 10, 10));
      JTextArea area = new JTextArea(Math.min(properties.size(), 20), 40);
      area.setEditable(false);
      area.setOpaque(false);
      area.setTabSize(16);

      Iterator iter = properties.keySet().iterator();
      if (iter.hasNext()) { // first line
        String key = (String) iter.next();
        area.append(key);
        area.append("\t");
        area.append(properties.getProperty(key));
      }
      while (iter.hasNext()) { // remaining lines
        area.append("\n");
        String key = (String) iter.next();
        area.append(key);
        area.append("\t");
        area.append(properties.getProperty(key));
      }
      add(new JScrollPane(area));
    }
Exemplo n.º 19
0
 public static void removeGroupProperties(String id, Properties properties) {
   for (Object key : properties.keySet()) {
     if (key.toString().startsWith(id + ".")) {
       properties.remove(key);
     }
   }
 }
 private ModuleOptionsMetadata makeSimpleModuleOptions(Properties props) {
   SimpleModuleOptionsMetadata result = new SimpleModuleOptionsMetadata();
   for (Object key : props.keySet()) {
     if (key instanceof String) {
       String propName = (String) key;
       Matcher matcher = DESCRIPTION_KEY_PATTERN.matcher(propName);
       if (!matcher.matches()) {
         continue;
       }
       String optionName = matcher.group(1);
       String description = props.getProperty(propName);
       Object defaultValue = props.getProperty(String.format("options.%s.default", optionName));
       String type = props.getProperty(String.format("options.%s.type", optionName));
       Class<?> clazz = null;
       if (type != null) {
         if (SHORT_CLASSNAMES.containsKey(type)) {
           clazz = SHORT_CLASSNAMES.get(type);
         } else {
           try {
             clazz = Class.forName(type);
           } catch (ClassNotFoundException e) {
             throw new IllegalStateException(
                 "Can't find class used for type of option '" + optionName + "': " + type);
           }
         }
       }
       ModuleOption moduleOption =
           new ModuleOption(optionName, description)
               .withDefaultValue(defaultValue)
               .withType(clazz);
       result.add(moduleOption);
     }
   }
   return result;
 }
  public static Properties getSystemProperties() {
    Properties res = ourSystemProperties;
    if (res == null) {
      res = new Properties();
      res.putAll(System.getProperties());

      for (Iterator<Object> itr = res.keySet().iterator(); itr.hasNext(); ) {
        final String propertyName = itr.next().toString();
        if (propertyName.startsWith("idea.")) {
          itr.remove();
        }
      }

      for (Map.Entry<String, String> entry : System.getenv().entrySet()) {
        String key = entry.getKey();
        if (key.startsWith("=")) {
          continue;
        }
        if (SystemInfo.isWindows) {
          key = key.toUpperCase();
        }
        res.setProperty("env." + key, entry.getValue());
      }

      ourSystemProperties = res;
    }
    return res;
  }
  /**
   * Transform JNDI properties passed in the form <tt>hibernate.jndi.*</tt> to the format accepted
   * by <tt>InitialContext</tt> by triming the leading "<tt>hibernate.jndi</tt>".
   */
  public static Properties getJndiProperties(Properties properties) {

    HashSet specialProps = new HashSet();
    specialProps.add(Environment.JNDI_CLASS);
    specialProps.add(Environment.JNDI_URL);

    Iterator iter = properties.keySet().iterator();
    Properties result = new Properties();
    while (iter.hasNext()) {
      String prop = (String) iter.next();
      if (prop.indexOf(Environment.JNDI_PREFIX) > -1 && !specialProps.contains(prop)) {
        result.setProperty(
            prop.substring(Environment.JNDI_PREFIX.length() + 1), properties.getProperty(prop));
      }
    }

    String jndiClass = properties.getProperty(Environment.JNDI_CLASS);
    String jndiURL = properties.getProperty(Environment.JNDI_URL);
    // we want to be able to just use the defaults,
    // if JNDI environment properties are not supplied
    // so don't put null in anywhere
    if (jndiClass != null) result.put(Context.INITIAL_CONTEXT_FACTORY, jndiClass);
    if (jndiURL != null) result.put(Context.PROVIDER_URL, jndiURL);

    return result;
  }
  @Override
  protected void processProperties(
      ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
      throws BeansException {
    /*
     * 覆盖父类的方法,截取解析到的参数值,放入自定义的map中,供外部调用。
     */

    // build the properties we need
    Map<String, String> tempProps = new HashMap<String, String>(props.size());
    PropertyPlaceholderHelper helper =
        new PropertyPlaceholderHelper(DEFAULT_PLACEHOLDER_PREFIX, DEFAULT_PLACEHOLDER_SUFFIX);
    for (Object keyObj : props.keySet()) {
      String key = String.valueOf(keyObj);
      String value = props.getProperty(key);
      if (StringUtils.hasText(value) && value.startsWith(SECRET_PREFIX)) {
        try {
          String tmp = CryptoUtil.decryptApi(value.substring(SECRET_PREFIX.length()));
          value = tmp;
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
      value = helper.replacePlaceholders(value, props);
      tempProps.put(key, value);
      props.setProperty(key, value);
    }
    // 这个map只读
    this.resolvedProps = Collections.unmodifiableMap(tempProps);
    PropsUtil.setProperties(resolvedProps);

    // 必须放在后面执行, 否则在xml配置属性的时候会不可用
    super.processProperties(beanFactoryToProcess, props);
  }
  public ConnectionlessQueryServicesImpl(
      QueryServices services, ConnectionInfo connInfo, Properties info) {
    super(services);
    userName = connInfo.getPrincipal();
    metaData = newEmptyMetaData();

    // Use KeyValueBuilder that builds real KeyValues, as our test utils require this
    this.kvBuilder = GenericKeyValueBuilder.INSTANCE;
    Configuration config = HBaseFactoryProvider.getConfigurationFactory().getConfiguration();
    for (Entry<String, String> entry : services.getProps()) {
      config.set(entry.getKey(), entry.getValue());
    }
    if (info != null) {
      for (Object key : info.keySet()) {
        config.set((String) key, info.getProperty((String) key));
      }
    }
    for (Entry<String, String> entry : connInfo.asProps()) {
      config.set(entry.getKey(), entry.getValue());
    }

    // Without making a copy of the configuration we cons up, we lose some of our properties
    // on the server side during testing.
    config = HBaseFactoryProvider.getConfigurationFactory().getConfiguration(config);
    TransactionManager txnManager = new TransactionManager(config);
    this.txSystemClient = new InMemoryTxSystemClient(txnManager);
  }
 @SuppressWarnings("unchecked")
 private void loadProperties() {
   try {
     log.debug("packName=" + packName);
     log.debug("fileName=" + fileName);
     FileInputStream fileInput = new FileInputStream(getFilePath(packName, fileName));
     prop.load(fileInput);
     String entityUp = prop.getProperty("Entity");
     log.debug("entityUp:" + entityUp);
     if (entityUp == null || entityUp.trim().equals("")) {
       log.warn("Entity not specified, exit!");
       return;
     }
     String entityLow = entityUp.substring(0, 1).toLowerCase() + entityUp.substring(1);
     log.debug("entityLow:" + entityLow);
     prop.put("entity", entityLow);
     if (log.isDebugEnabled()) {
       Set ps = prop.keySet();
       for (Object o : ps) {
         log.debug(o + "=" + prop.get(o));
       }
     }
   } catch (FileNotFoundException e) {
     e.printStackTrace();
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
Exemplo n.º 26
0
 public static void setSystemProperties(ContextAware contextAware, Properties props) {
   for (Object o : props.keySet()) {
     String key = (String) o;
     String value = props.getProperty(key);
     setSystemProperty(contextAware, key, value);
   }
 }
  /** @param args */
  public static void main(String[] args) {

    try {
      InputStream in =
          SupportDBUrlStore.class.getResourceAsStream("dburl.properties"); // $NON-NLS-1$
      PROP.load(in);
      in.close();
      Set<?> s = PROP.keySet();
      // System.out.println(s.toString());
      Iterator<?> it = s.iterator();
      while (it.hasNext()) {
        String id = (String) it.next();
        String value = PROP.getProperty(id);
        System.out.println("\n" + id + "-------" + value); // $NON-NLS-1$ //$NON-NLS-2$

        // Object[] arguments = { "10.78.23.23", "33456", "testDB" };
        Object[] arguments = {
          "{hostname}", "{port}", "{dbname}", ""
        }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
        System.out.println(MessageFormat.format(value, arguments));
      }
      // System.out.println(p.toString());
    } catch (Exception e) {
      log.error(e, e);
    }
  }
  private Properties getModelConnectionProperties(ModelResource mr) {

    try {
      if (ModelIdentifier.isRelationalSourceModel(mr)) {
        IConnectionInfoProvider provider = null;

        try {
          provider = getProvider(mr);
        } catch (Exception e) {
          // If provider throws exception its OK because some models may not have connection info.
        }

        if (provider != null) {
          Properties properties = provider.getProfileProperties(mr); // ConnectionProperties(mr);
          Properties p2 = provider.getConnectionProperties(mr);
          String translatorName = provider.getTranslatorName(mr);
          for (Object key : p2.keySet()) {
            properties.put(key, p2.get(key));
          }
          if (translatorName != null) {
            properties.put(getString("translatorKey"), translatorName); // $NON-NLS-1$
          }
          if (properties != null && !properties.isEmpty()) {
            return properties;
          }
        }
      }
    } catch (CoreException e) {
      DatatoolsUiConstants.UTIL.log(e);
    }

    return null;
  }
Exemplo n.º 29
0
 private static String propsToString(Properties props) {
   StringBuilder builder = new StringBuilder();
   for (Object key : props.keySet()) {
     builder.append(key).append("=").append(props.getProperty(key.toString())).append("\n");
   }
   return builder.toString();
 }
Exemplo n.º 30
0
  private String createParameterString() {

    // put required parameters
    for (OauthConstants constant : OauthConstants.values()) {
      String key = OAuth.percentEncode(constant.name());
      String value = OAuth.percentEncode(properties.getProperty(constant.name()));
      if (constant.equals(OauthConstants.oauth_nonce)) {
        value = OAuth.percentEncode(nonce);
      }
      if (constant.equals(OauthConstants.oauth_timestamp)) {
        value = OAuth.percentEncode(String.valueOf(timestamp));
      }
      parameterMap.put(key, value);
    }

    // put optional parameters
    for (Object key_ : optionalParameters.keySet()) {
      String keyStr = (String) key_;
      String key = OAuth.percentEncode(keyStr);
      String value = OAuth.percentEncode(optionalParameters.get(keyStr).toString());
      parameterMap.put(key, value);
    }

    StringBuilder builder = new StringBuilder();

    for (String s : parameterMap.keySet()) {
      builder.append(s).append('=').append(parameterMap.get(s)).append("&");
    }
    builder.setLength(builder.lastIndexOf("&"));
    return builder.toString();
  }