content: package monty.solr.util;
  
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.util.HashMap;
  import java.util.Properties;
  
  
  /**
   * Automatic setup for Test classes, do not use this in a production
   * environment! (unless you are really too lazy ;))
   *
   * @author rchyla
   */
  
  
  public class MontySolrSetup {
      private static final HashMap<String, Properties> prop = new HashMap<String, Properties>();
  
  
      /**
       * Load the properties from the file (build.properties)
       * This is used only by the tests that need a working
       * MontySolr instance
       * <p>
       * By default, this returns the Properties for the core
       *
       * @return Properties
       */
      public static Properties getProperties(String projectName) {
          return getProperties(getMontySolrHome(), projectName); // the default MontySolr main project
      }
  
      public static Properties getProperties(String base, String project) {
          project = project.trim();
          while (project.indexOf("/") == 0) {
              project = project.substring(1);
          }
          while (project.indexOf("/") == project.length()) {
              project = project.substring(0, project.length() - 1);
          }
          if (prop.containsKey(project)) {
              return prop.get(project);
          }
  
          Properties p = loadProperties(base, project);
          prop.put(project, p);
          return p;
      }
  
      /**
       * MontySolr depends on the properties file for unittesting, as it was too
       * much hassle to load interpolated strings from the build.properties file
       * (without adding more jars) and the discovery of files using file
       * structure crawling is ugly.
       *
       * @return Properties
       */
  
      public static Properties loadProperties(String base, String project) throws IllegalStateException {
          base = base + "/" + project;
          Properties prop = new Properties();
          try {
              prop.load(new FileInputStream(new File(base
                      + "/build.properties")));
          } catch (IOException e) {
              throw new IllegalStateException("Your montysolr installation does not have "
                      + base + "/build.properties file! "
                      + "You should fix this (by running 'ant build-all', or 'ant write-properties')");
          }
          return prop;
      }
  
      public static String getSolrHome() {
          String base = getMontySolrHome();
  
          String home = System.getProperty("solr.solr.home");
          if (home != null) {
              if ((new File(home)).exists() && System.getProperty("montysolr.ignore.home") != null) {
                  System.err.println("MontySolrSetup: solr.solr.home is set to '" + home + "'\n" +
                          "...ignoring the test setup");
                  return home.replace('\\', '/');
              } else {
                  System.err.println("MontySolrSetup: solr.solr.home is set to '" + home + "'\n" +
                          "...but this path does not exist");
              }
          }
  
          String solr_home = null;
  
          Properties p = getProperties("build");
          if (p != null && p.containsKey("solr.home")) {
              solr_home = p.getProperty("solr.home");
          }
  
          if (solr_home == null || !(new File(solr_home).exists())) {
              throw new IllegalStateException(
                      "solr.home is not accessible - you should run ant write-properties: "
                              + solr_home);
          }
  
          File s = new File(solr_home);
          File s_level_down = new File(s.getAbsolutePath() + "/solr");
  
          if (s_level_down.exists())
              return s_level_down.getAbsolutePath().replace('\\', '/');
  
          if (s.exists())
              return s.getAbsolutePath().replace('\\', '/');
  
          throw new IllegalStateException(
                  "Cannot determine the folder with solr installation");
      }
  
      /**
       * Gets a resource from the context classloader as {@link File}. This method
       * should only be used, if a real file is needed. To get a stream, code
       * should prefer {@link Class#getResourceAsStream} using
       * {@code this.getClass()}.
       */
      public static File getFile(String name) {
          try {
              File file = new File(name);
              if (!file.exists()) {
                  file = new File(Thread.currentThread().getContextClassLoader()
                          .getResource(name).toURI());
              }
              return file;
          } catch (Exception e) {
              /* more friendly than NPE */
              throw new RuntimeException("Cannot find resource: " + name);
          }
      }
  
      static String determineMontySourceHome() {
          File base = getFile("examples/README.txt").getAbsoluteFile();
          return new File(base.getParentFile().getParentFile(), "test-files/")
                  .getAbsolutePath();
      }
  
      /**
       * Returns the root folder of montysolr
       *
       * @return String
       */
      public static String getMontySolrHome() {
          File base = new File(System.getProperty("user.dir"));
          // File base = getFile("solr/conf").getAbsoluteFile();
          while (!new File(base, "montysolr/montysolr.md").exists()) {
              base = base.getParentFile();
          }
          return base.getAbsolutePath().replace('\\', '/');
      }
  
  
      /**
       * Trick to find any existing folder/file inside the main module path and
       * return it to be set by python into the PYTHONPATH
       *
       * @return String
       */
      public static String getChildModulePath(String modulePath) throws Exception {
          File f = new File(modulePath);
          if (f.isFile()) {
              return f.getAbsolutePath();
          } else if (f.exists()) {
              for (String child : f.list()) {
                  return new File(f.getAbsolutePath() + "/" + child)
                          .getAbsolutePath();
              }
          }
          throw new Exception("The module.path must exist: " + modulePath);
      }
  
  
  }
  