예제 #1
0
 /** Sets Tesseract's internal parameters. */
 private void setTessVariables() {
   Enumeration<?> em = prop.propertyNames();
   while (em.hasMoreElements()) {
     String key = (String) em.nextElement();
     api.TessBaseAPISetVariable(handle, key, prop.getProperty(key));
   }
 }
  public static Map<String, String> readProperties(InputStream inputStream) {
    Map<String, String> propertiesMap = null;
    try {
      propertiesMap = new LinkedHashMap<String, String>();

      Properties properties = new Properties();
      properties.load(inputStream);

      Enumeration<?> enumeration = properties.propertyNames();
      while (enumeration.hasMoreElements()) {
        String key = (String) enumeration.nextElement();
        String value = (String) properties.get(key);
        propertiesMap.put(key, value);
      }
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      if (inputStream != null) {
        try {
          inputStream.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
    return propertiesMap;
  }
예제 #3
0
 private void loadLanguageMappings(Properties props) {
   Enumeration<?> en = props.propertyNames();
   while (en.hasMoreElements()) {
     String propName = (String) en.nextElement();
     String propVal = props.getProperty(propName);
     if (propName.startsWith(".")) {
       // This is an extension mapping
       if (propName.equals(".")) {
         // The default mapping
         defaultLanguageImplName = propVal;
       } else {
         propName = propName.substring(1);
         extensionMappings.put(propName, propVal);
       }
     } else {
       // value is made up of an optional module name followed by colon followed by the
       // FQCN of the factory
       int colonIndex = propVal.lastIndexOf(COLON);
       String moduleName;
       String factoryName;
       if (colonIndex != -1) {
         moduleName = propVal.substring(0, colonIndex);
         factoryName = propVal.substring(colonIndex + 1);
       } else {
         throw new IllegalArgumentException(
             "Language mapping: " + propVal + " does not specify an implementing module");
       }
       LanguageImplInfo langImpl = new LanguageImplInfo(moduleName, factoryName);
       languageImpls.put(propName, langImpl);
       extensionMappings.put(propName, propName); // automatically register the name as a mapping
     }
   }
 }
예제 #4
0
 /**
  * Add set of properties to this object. This method will replace the value of any properties that
  * already existed.
  */
 public void setProperties(Properties props) {
   Enumeration names = props.propertyNames();
   while (names.hasMoreElements()) {
     String name = (String) names.nextElement();
     setProperty(name, props.getProperty(name));
   }
 }
예제 #5
0
  public Factory readTheFile() {
    try {
      // Reading the file
      String filename = "file.properties";
      input = new FileInputStream(filename);
      if (input == null) {
        System.out.println("Sorry, unable to find " + filename);
        return null;
      }

      prop.load(input);

      Enumeration<?> e = prop.propertyNames();
      while (e.hasMoreElements()) {
        String key = (String) e.nextElement();
        String value = prop.getProperty(key);

        // Setting the shop name
        factory.setShopName(key);
        // Splitting by type
        String[] valuesList = value.split(", ");
        for (String values : valuesList) {
          // Splitting by value
          // System.out.println(values);
          String[] typeAndValues = values.split(":");
          typeAndValues[1] = typeAndValues[1].trim();
          String[] valueEach = typeAndValues[1].split(" ");

          // Storing values to the factory
          if (typeAndValues[0].equals("Sport")) {
            factory.addSport(valueEach[0], valueEach[1]);
          } else if (typeAndValues[0].equals("Logical")) {
            factory.addLogical(valueEach[0], valueEach[1]);
          }
        }
      }
    } catch (IOException ex) {
      ex.printStackTrace();
    } finally {
      if (input != null) {
        try {
          input.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }

    return factory;
  }
예제 #6
0
  private void loadConfiguration() throws RuntimeConfigException {
    trace(String.format("Loading configuration from [%s]", configFilePath));
    try {
      InputStream stream = new FileInputStream(configFilePath);
      // InputStream stream1 = new FileInputStream("config/ocsswws.config");
      try {
        Properties fileProperties = new Properties();
        fileProperties.load(stream);
        // @todo check tests - code was not backward compatible with Java 5
        // so i changed it - but this is not the only place of uncompatibilty
        // add default properties so that they override file properties
        // Set<String> propertyNames = fileProperties.stringPropertyNames();
        //                for (String propertyName : propertyNames) {
        //                    String propertyValue = fileProperties.getProperty(propertyName);
        //                    if (!isPropertySet(propertyName)) {
        //                        setProperty(propertyName, propertyValue);
        //                        trace(String.format("Configuration property [%s] added",
        // propertyName));
        //                    } else {
        //                        trace(String.format("Configuration property [%s] ignored",
        // propertyName));
        //                    }
        //                }

        Enumeration<?> enumeration = fileProperties.propertyNames();
        while (enumeration.hasMoreElements()) {
          final Object key = enumeration.nextElement();
          if (key instanceof String) {
            final Object value = fileProperties.get(key);
            if (value instanceof String) {
              final String keyString = (String) key;
              String propertyValue = fileProperties.getProperty(keyString);
              if (!isPropertySet(keyString)) {
                setProperty(keyString, propertyValue);
                trace(String.format("Configuration property [%s] added", keyString));
              } else {
                trace(String.format("Configuration property [%s] ignored", keyString));
              }
            }
          }
        }
      } finally {
        stream.close();
      }
    } catch (IOException e) {
      throw new RuntimeConfigException(
          String.format("Failed to load configuration [%s]", configFilePath), e);
    }
  }
예제 #7
0
파일: Macro.java 프로젝트: bramk/bnd
 /**
  * Take all the properties and translate them to actual values. This method takes the set
  * properties and traverse them over all entries, including the default properties for that
  * properties. The values no longer contain macros.
  *
  * @return A new Properties with the flattened values
  */
 public Properties getFlattenedProperties() {
   // Some macros only work in a lower processor, so we
   // do not report unknown macros while flattening
   flattening = true;
   try {
     Properties flattened = new Properties();
     Properties source = domain.getProperties();
     for (Enumeration<?> e = source.propertyNames(); e.hasMoreElements(); ) {
       String key = (String) e.nextElement();
       if (!key.startsWith("_"))
         if (key.startsWith("-")) flattened.put(key, source.getProperty(key));
         else flattened.put(key, process(source.getProperty(key)));
     }
     return flattened;
   } finally {
     flattening = false;
   }
 }
예제 #8
0
  public void loadProperties(File file) throws IOException {
    Properties input = new Properties();

    FileInputStream stream = null;
    try {
      stream = new FileInputStream(file);
      input.load(stream);

      for (Enumeration e = input.propertyNames(); e.hasMoreElements(); ) {
        String key = (String) e.nextElement();
        doSetValue(key, input.getProperty(key));
      }
    } finally {
      if (stream != null) {
        stream.close();
      }
    }
  }
예제 #9
0
  public static void showServerInfo(PrintStream out) {
    out.println("Server Info");
    out.println(
        " getDocumentBuilderFactoryVersion(): "
            + XMLEntityResolver.getDocumentBuilderFactoryVersion());
    out.println();

    Properties sysp = System.getProperties();
    Enumeration e = sysp.propertyNames();
    List<String> list = Collections.list(e);
    Collections.sort(list);

    out.println("System Properties:");
    for (String name : list) {
      String value = System.getProperty(name);
      out.println("  " + name + " = " + value);
    }
    out.println();
  }
예제 #10
0
  public void setLanguage(String par1Str) {
    if (!par1Str.equals(this.currentLanguage)) {
      Properties var2 = new Properties();

      try {
        this.loadLanguage(var2, "en_US");
      } catch (IOException var8) {;
      }

      this.isUnicode = false;

      if (!"en_US".equals(par1Str)) {
        try {
          this.loadLanguage(var2, par1Str);
          Enumeration var3 = var2.propertyNames();

          while (var3.hasMoreElements() && !this.isUnicode) {
            Object var4 = var3.nextElement();
            Object var5 = var2.get(var4);

            if (var5 != null) {
              String var6 = var5.toString();

              for (int var7 = 0; var7 < var6.length(); ++var7) {
                if (var6.charAt(var7) >= 256) {
                  this.isUnicode = true;
                  break;
                }
              }
            }
          }
        } catch (IOException var9) {
          var9.printStackTrace();
          return;
        }
      }

      this.currentLanguage = par1Str;
      this.translateTable = var2;
    }
  }
예제 #11
0
 public JPanel getPanelForProperties(Properties propsArg) {
   // clear();
   propKeyList = new ArrayList();
   propValueList = new ArrayList();
   for (Enumeration e = propsArg.propertyNames(); e.hasMoreElements(); ) {
     String name = (String) e.nextElement();
     String value = (String) propsArg.getProperty(name);
     XmlUIElement el = getXmlUIElementFor("textfield");
     if (el != null) {
       propKeyList.add(name);
       el.setValue(value);
       if (name.endsWith("#")) {
         el.setLabelName(name.substring(0, name.length() - 1));
       } else {
         el.setLabelName(name);
       }
       propValueList.add(el);
     }
   }
   return getPanelFor(propValueList);
 }
예제 #12
0
 // Private method to be called when the configuration has
 // changed to apply any level settings to any pre-existing loggers.
 private synchronized void setLevelsOnExistingLoggers() {
   Enumeration enum_ = props.propertyNames();
   while (enum_.hasMoreElements()) {
     String key = (String) enum_.nextElement();
     if (!key.endsWith(".level")) {
       // Not a level definition.
       continue;
     }
     int ix = key.length() - 6;
     String name = key.substring(0, ix);
     Level level = getLevelProperty(key, null);
     if (level == null) {
       System.err.println("Bad level value for property: " + key);
       continue;
     }
     Logger l = getLogger(name);
     if (l == null) {
       continue;
     }
     l.setLevel(level);
   }
 }
  @Override
  public Response serve(String uri, String method, Properties header, Properties parms) {
    if (!uri.equals("/mediaserver")) {
      return super.serve(uri, method, header, parms); // this way we can
      // also serve up
      // normal files and
      // content
    }

    logger.fine(method + " '" + uri + "' ");

    Enumeration<?> e = header.propertyNames();
    while (e.hasMoreElements()) {
      String value = (String) e.nextElement();
      logger.fine("  HDR: '" + value + "' = '" + header.getProperty(value) + "'");
    }
    e = parms.propertyNames();
    while (e.hasMoreElements()) {
      String value = (String) e.nextElement();
      logger.fine("  PRM: '" + value + "' = '" + parms.getProperty(value) + "'");
    }

    // TODO: check the actual path...

    final String mediaPath = parms.getProperty("media");
    final String outputFormatStr = parms.getProperty("format");
    final String mimeType = parms.getProperty("mime");
    logger.info("requested media: " + mediaPath);
    logger.info("requested mime type: " + mimeType);
    if (mediaPath == null)
      return new Response(HTTP_FORBIDDEN, "text/plain", "mediaPath parameter not specified");
    if (mimeType == null)
      return new Response(HTTP_FORBIDDEN, "text/plain", "mimeType parameter not specified");

    // TODO: if we aren't performing any transcoding, just serve the file up
    // directly.
    // TODO: capture sources need to be treated as singletons, with some
    // kind of broadcasting/cloning to ensure
    // that multiple connections can be made.

    final String serverSideUrlStr = mediaPath; // URLUtils.createUrlStr(new
    // File(mediaPath)); // TODO:
    // enforce that we can't just
    // serve up anything anywhere
    final ContentDescriptor outputContentDescriptor =
        new FileTypeDescriptor(ContentDescriptor.mimeTypeToPackageName(mimeType));

    final Format outputFormat;
    if (outputFormatStr == null) {
      outputFormat = null;
    } else {
      try {
        outputFormat = FormatArgUtils.parse(outputFormatStr);
      } catch (ParseException e1) {
        logger.log(Level.WARNING, "" + e1, e1);
        return new Response(HTTP_FORBIDDEN, "text/plain", "" + e1);
      }
    }

    logger.info("serverSideUrlStr: " + serverSideUrlStr);
    logger.info("outputContentDescriptor: " + outputContentDescriptor);
    logger.info("outputFormat: " + outputFormat);

    final InputStream is;
    try {
      is = getInputStream(serverSideUrlStr, outputFormat, outputContentDescriptor);
    } catch (Exception e1) {
      return new Response(HTTP_FORBIDDEN, "text/plain", "" + e1);
    }

    final String responseMimeType;
    // workaround for the problem that the multipart/x-mixed-replace
    // boundary is not stored anywhere.
    // this assumes that if we are serving multipart/x-mixed-replace data,
    // that MultipartMixedReplaceMux is being used.
    if (mimeType.equals("multipart/x-mixed-replace"))
      responseMimeType = mimeType + ";boundary=" + MultipartMixedReplaceMux.BOUNDARY;
    else responseMimeType = mimeType;
    logger.info("Response mime type: " + responseMimeType);
    return new Response(HTTP_OK, responseMimeType, is);
  }
예제 #14
0
파일: Main.java 프로젝트: Acehust12/osgi
  /**
   * Loads the configuration properties in the configuration property file associated with the
   * framework installation; these properties are accessible to the framework and to bundles and are
   * intended for configuration purposes. By default, the configuration property file is located in
   * the <tt>conf/</tt> directory of the Felix installation directory and is called
   * "<tt>config.properties</tt>". The installation directory of Felix is assumed to be the parent
   * directory of the <tt>felix.jar</tt> file as found on the system class path property. The
   * precise file from which to load configuration properties can be set by initializing the
   * "<tt>felix.config.properties</tt>" system property to an arbitrary URL.
   *
   * @return A <tt>Properties</tt> instance or <tt>null</tt> if there was an error.
   */
  public static Properties loadConfigProperties() {
    // The config properties file is either specified by a system
    // property or it is in the conf/ directory of the Felix
    // installation directory.  Try to load it from one of these
    // places.

    // See if the property URL was specified as a property.
    URL propURL = null;
    String custom = System.getProperty(CONFIG_PROPERTIES_PROP);
    if (custom != null) {
      try {
        propURL = new URL(custom);
      } catch (MalformedURLException ex) {
        System.err.print("Main: " + ex);
        return null;
      }
    } else {
      // Determine where the configuration directory is by figuring
      // out where felix.jar is located on the system class path.
      File confDir = null;
      String classpath = System.getProperty("java.class.path");
      int index = classpath.toLowerCase().indexOf("felix.jar");
      int start = classpath.lastIndexOf(File.pathSeparator, index) + 1;
      if (index >= start) {
        // Get the path of the felix.jar file.
        String jarLocation = classpath.substring(start, index);
        // Calculate the conf directory based on the parent
        // directory of the felix.jar directory.
        confDir =
            new File(
                new File(new File(jarLocation).getAbsolutePath()).getParent(), CONFIG_DIRECTORY);
      } else {
        // Can't figure it out so use the current directory as default.
        confDir = new File(System.getProperty("user.dir"), CONFIG_DIRECTORY);
      }

      try {
        propURL = new File(confDir, CONFIG_PROPERTIES_FILE_VALUE).toURL();
      } catch (MalformedURLException ex) {
        System.err.print("Main: " + ex);
        return null;
      }
    }

    // Read the properties file.
    Properties props = new Properties();
    InputStream is = null;
    try {
      // Try to load config.properties.
      is = propURL.openConnection().getInputStream();
      props.load(is);
      is.close();
    } catch (Exception ex) {
      // Try to close input stream if we have one.
      try {
        if (is != null) is.close();
      } catch (IOException ex2) {
        // Nothing we can do.
      }

      return null;
    }

    // Perform variable substitution for system properties.
    for (Enumeration e = props.propertyNames(); e.hasMoreElements(); ) {
      String name = (String) e.nextElement();
      props.setProperty(name, Util.substVars(props.getProperty(name), name, null, props));
    }

    return props;
  }
예제 #15
0
  @SuppressWarnings("unchecked")
  public static void main(String[] args) {
    String dbname;
    Properties props = new Properties();
    Properties fileprops = new Properties();
    boolean dotransactions = true;
    int threadcount = 1;
    int target = 0;
    boolean status = false;
    String label = "";

    // parse arguments
    int argindex = 0;

    if (args.length == 0) {
      usageMessage();
      System.exit(0);
    }

    while (args[argindex].startsWith("-")) {
      if (args[argindex].compareTo("-threads") == 0) {
        argindex++;
        if (argindex >= args.length) {
          usageMessage();
          System.exit(0);
        }
        int tcount = Integer.parseInt(args[argindex]);
        props.setProperty("threadcount", tcount + "");
        argindex++;
      } else if (args[argindex].compareTo("-target") == 0) {
        argindex++;
        if (argindex >= args.length) {
          usageMessage();
          System.exit(0);
        }
        int ttarget = Integer.parseInt(args[argindex]);
        props.setProperty("target", ttarget + "");
        argindex++;
      } else if (args[argindex].compareTo("-load") == 0) {
        dotransactions = false;
        argindex++;
      } else if (args[argindex].compareTo("-t") == 0) {
        dotransactions = true;
        argindex++;
      } else if (args[argindex].compareTo("-s") == 0) {
        status = true;
        argindex++;
      } else if (args[argindex].compareTo("-db") == 0) {
        argindex++;
        if (argindex >= args.length) {
          usageMessage();
          System.exit(0);
        }
        props.setProperty("db", args[argindex]);
        argindex++;
      } else if (args[argindex].compareTo("-l") == 0) {
        argindex++;
        if (argindex >= args.length) {
          usageMessage();
          System.exit(0);
        }
        label = args[argindex];
        argindex++;
      } else if (args[argindex].compareTo("-P") == 0) {
        argindex++;
        if (argindex >= args.length) {
          usageMessage();
          System.exit(0);
        }
        String propfile = args[argindex];
        argindex++;

        Properties myfileprops = new Properties();
        try {
          myfileprops.load(new FileInputStream(propfile));
        } catch (IOException e) {
          System.out.println(e.getMessage());
          System.exit(0);
        }

        // Issue #5 - remove call to stringPropertyNames to make compilable under Java 1.5
        for (Enumeration e = myfileprops.propertyNames(); e.hasMoreElements(); ) {
          String prop = (String) e.nextElement();

          fileprops.setProperty(prop, myfileprops.getProperty(prop));
        }

      } else if (args[argindex].compareTo("-p") == 0) {
        argindex++;
        if (argindex >= args.length) {
          usageMessage();
          System.exit(0);
        }
        int eq = args[argindex].indexOf('=');
        if (eq < 0) {
          usageMessage();
          System.exit(0);
        }

        String name = args[argindex].substring(0, eq);
        String value = args[argindex].substring(eq + 1);
        props.put(name, value);
        // System.out.println("["+name+"]=["+value+"]");
        argindex++;
      } else {
        System.out.println("Unknown option " + args[argindex]);
        usageMessage();
        System.exit(0);
      }

      if (argindex >= args.length) {
        break;
      }
    }

    if (argindex != args.length) {
      usageMessage();
      System.exit(0);
    }

    // set up logging
    // BasicConfigurator.configure();

    // overwrite file properties with properties from the command line

    // Issue #5 - remove call to stringPropertyNames to make compilable under Java 1.5
    for (Enumeration e = props.propertyNames(); e.hasMoreElements(); ) {
      String prop = (String) e.nextElement();

      fileprops.setProperty(prop, props.getProperty(prop));
    }

    props = fileprops;

    if (!checkRequiredProperties(props)) {
      System.exit(0);
    }

    long maxExecutionTime = Integer.parseInt(props.getProperty(MAX_EXECUTION_TIME, "0"));

    // get number of threads, target and db
    threadcount = Integer.parseInt(props.getProperty("threadcount", "1"));
    dbname = props.getProperty("db", "com.yahoo.ycsb.BasicDB");
    target = Integer.parseInt(props.getProperty("target", "0"));

    // compute the target throughput
    double targetperthreadperms = -1;
    if (target > 0) {
      double targetperthread = ((double) target) / ((double) threadcount);
      targetperthreadperms = targetperthread / 1000.0;
    }

    System.out.println("YCSB Client 0.1");
    System.out.print("Command line:");
    for (int i = 0; i < args.length; i++) {
      System.out.print(" " + args[i]);
    }
    System.out.println();
    System.err.println("Loading workload...");

    // show a warning message that creating the workload is taking a while
    // but only do so if it is taking longer than 2 seconds
    // (showing the message right away if the setup wasn't taking very long was confusing people)
    Thread warningthread =
        new Thread() {
          public void run() {
            try {
              sleep(2000);
            } catch (InterruptedException e) {
              return;
            }
            System.err.println(" (might take a few minutes for large data sets)");
          }
        };

    warningthread.start();

    // set up measurements
    Measurements.setProperties(props);

    // load the workload
    ClassLoader classLoader = Client.class.getClassLoader();

    Workload workload = null;

    try {
      Class workloadclass = classLoader.loadClass(props.getProperty(WORKLOAD_PROPERTY));

      workload = (Workload) workloadclass.newInstance();
    } catch (Exception e) {
      e.printStackTrace();
      e.printStackTrace(System.out);
      System.exit(0);
    }

    try {
      workload.init(props);
    } catch (WorkloadException e) {
      e.printStackTrace();
      e.printStackTrace(System.out);
      System.exit(0);
    }

    warningthread.interrupt();

    // run the workload

    System.err.println("Starting test.");

    int opcount;
    if (dotransactions) {
      opcount = Integer.parseInt(props.getProperty(OPERATION_COUNT_PROPERTY, "0"));
    } else {
      if (props.containsKey(INSERT_COUNT_PROPERTY)) {
        opcount = Integer.parseInt(props.getProperty(INSERT_COUNT_PROPERTY, "0"));
      } else {
        opcount = Integer.parseInt(props.getProperty(RECORD_COUNT_PROPERTY, "0"));
      }
    }

    Vector<Thread> threads = new Vector<Thread>();

    for (int threadid = 0; threadid < threadcount; threadid++) {
      DB db = null;
      try {
        db = DBFactory.newDB(dbname, props);
      } catch (UnknownDBException e) {
        System.out.println("Unknown DB " + dbname);
        System.exit(0);
      }

      Thread t =
          new ClientThread(
              db,
              dotransactions,
              workload,
              threadid,
              threadcount,
              props,
              opcount / threadcount,
              targetperthreadperms);

      threads.add(t);
      // t.start();
    }

    StatusThread statusthread = null;

    if (status) {
      boolean standardstatus = false;
      if (props.getProperty("measurementtype", "").compareTo("timeseries") == 0) {
        standardstatus = true;
      }
      statusthread = new StatusThread(threads, label, standardstatus);
      statusthread.start();
    }

    long st = System.currentTimeMillis();

    for (Thread t : threads) {
      t.start();
    }

    Thread terminator = null;

    if (maxExecutionTime > 0) {
      terminator = new TerminatorThread(maxExecutionTime, threads, workload);
      terminator.start();
    }

    int opsDone = 0;

    for (Thread t : threads) {
      try {
        t.join();
        opsDone += ((ClientThread) t).getOpsDone();
      } catch (InterruptedException e) {
      }
    }

    long en = System.currentTimeMillis();

    if (terminator != null && !terminator.isInterrupted()) {
      terminator.interrupt();
    }

    if (status) {
      statusthread.interrupt();
    }

    try {
      workload.cleanup();
    } catch (WorkloadException e) {
      e.printStackTrace();
      e.printStackTrace(System.out);
      System.exit(0);
    }

    try {
      exportMeasurements(props, opsDone, en - st);
    } catch (IOException e) {
      System.err.println("Could not export measurements, error: " + e.getMessage());
      e.printStackTrace();
      System.exit(-1);
    }

    System.exit(0);
  }