Exemple #1
1
  /** @see java.net.URLStreamHandler#openConnection(URL) */
  protected URLConnection openConnection(URL u) throws IOException {

    try {

      URL otherURL = new URL(u.getFile());
      String host = otherURL.getHost();
      String protocol = otherURL.getProtocol();
      int port = otherURL.getPort();
      String file = otherURL.getFile();
      String query = otherURL.getQuery();
      // System.out.println("Trying to load: " + u.toExternalForm());
      String internalFile = null;
      if (file.indexOf("!/") != -1) {
        internalFile = file.substring(file.indexOf("!/") + 2);
        file = file.substring(0, file.indexOf("!/"));
      }
      URL subURL = new URL(protocol, host, port, file);
      File newFile;
      if (cacheList.containsKey(subURL.toExternalForm())) {
        newFile = cacheList.get(subURL.toExternalForm());
      } else {
        InputStream is = (InputStream) subURL.getContent();
        String update = subURL.toExternalForm().replace(":", "_");
        update = update.replace("/", "-");
        File f = File.createTempFile("pack", update);
        f.deleteOnExit();
        FileOutputStream fostream = new FileOutputStream(f);
        copyStream(new BufferedInputStream(is), fostream);

        // Unpack
        newFile = File.createTempFile("unpack", update);
        newFile.deleteOnExit();
        fostream = new FileOutputStream(newFile);
        BufferedOutputStream bos = new BufferedOutputStream(fostream, 50 * 1024);
        JarOutputStream jostream = new JarOutputStream(bos);
        Unpacker unpacker = Pack200.newUnpacker();
        long start = System.currentTimeMillis();

        unpacker.unpack(f, jostream);
        printMessage(
            "Unpack of " + update + " took " + (System.currentTimeMillis() - start) + "ms");
        jostream.close();
        fostream.close();
        cacheList.put(subURL.toExternalForm(), newFile);
      }
      if (internalFile != null) {

        URL directoryURL = new URL("jar:" + newFile.toURL().toExternalForm() + "!/" + internalFile);
        printMessage("Using DirectoryURL:" + directoryURL);
        return directoryURL.openConnection();
      } else return newFile.toURL().openConnection();
    } catch (Exception ex) {
      ex.printStackTrace();
    }
    printMessage("Returning null for: " + u.toExternalForm());
    return null;
  }
Exemple #2
0
 static {
   Attributes m = null;
   final URL loc = Prop.LOCATION;
   if (loc != null) {
     final String jar = loc.getFile();
     try {
       final ClassLoader cl = JarManifest.class.getClassLoader();
       final Enumeration<URL> list = cl.getResources("META-INF/MANIFEST.MF");
       while (list.hasMoreElements()) {
         final URL url = list.nextElement();
         if (!url.getFile().contains(jar)) continue;
         final InputStream in = url.openStream();
         try {
           m = new Manifest(in).getMainAttributes();
           break;
         } finally {
           in.close();
         }
       }
     } catch (final IOException ex) {
       Util.errln(ex);
     }
   }
   MAP = m;
 }
 private List<String> searchDependencyEngineConfigFiles(
     String prefixPackageName, Class<?> contentLoaderClass) {
   List<String> fileNames = new ArrayList<String>();
   Enumeration<?> enumFiles = findConfigFileUrls(prefixPackageName, contentLoaderClass);
   while (enumFiles != null && enumFiles.hasMoreElements()) {
     URL url = (URL) enumFiles.nextElement();
     if (url == null || url.getFile() == null || url.getFile().length() <= 1) continue;
     String fileName = getFileName(url.getPath());
     if (url.getProtocol() != null && url.getProtocol().equalsIgnoreCase("jar")) {
       String elementInJar = getJarFileEntryName(url.getPath());
       JarFile jarFile = openJar(url);
       List<JarEntry> entries = Collections.list(jarFile.entries());
       for (JarEntry entry : entries) {
         String entryName = entry.getName();
         if (entryName.startsWith(elementInJar)) {
           if (!entry.isDirectory() && entryName.matches(dependencyEngineConfigFileRegex)) {
             fileNames.add(fileName + "!" + "/" + entry.toString());
           }
         }
       }
     } else {
       List<String> list = searchDependencyEngineConfigFiles(new File(fileName));
       if (list != null && list.size() > 0) {
         fileNames.addAll(list);
       }
     }
   }
   return fileNames;
 }
  private Map<String, Properties> getBundleDefaultProperties(long bundleId) throws IOException {
    Bundle bundle = bundleContext.getBundle(bundleId);
    // Find all property files in main bundle directory
    Enumeration<URL> enumeration = bundle.findEntries("", "*.properties", false);
    Map<String, Properties> allDefaultProperties = new LinkedHashMap<>();

    if (enumeration != null) {
      while (enumeration.hasMoreElements()) {
        InputStream is = null;
        URL url = enumeration.nextElement();
        try {
          is = url.openStream();
          Properties defaultBundleProperties = new Properties();
          defaultBundleProperties.load(is);
          if (!url.getFile().isEmpty()) {
            // We want to store plain filename, without unnecessary slash prefix
            allDefaultProperties.put(url.getFile().substring(1), defaultBundleProperties);
          }
        } catch (IOException e) {
          LOGGER.error("Error while reading or retrieving default properties", e);
        } finally {
          IOUtils.closeQuietly(is);
        }
      }
    }
    return allDefaultProperties;
  }
Exemple #5
0
 /**
  * Opens a stream from a public and system ID.
  *
  * @param publicID the public ID, which may be null
  * @param systemID the system ID, which is never null
  * @throws java.net.MalformedURLException if the system ID does not contain a valid URL
  * @throws java.io.FileNotFoundException if the system ID refers to a local file which does not
  *     exist
  * @throws java.io.IOException if an error occurred opening the stream
  */
 public Reader openStream(final String publicID, final String systemID)
     throws MalformedURLException, FileNotFoundException, IOException {
   URL url = new URL(currentReader.systemId, systemID);
   if (url.getRef() != null) {
     final String ref = url.getRef();
     if (url.getFile().length() > 0) {
       url = new URL(url.getProtocol(), url.getHost(), url.getPort(), url.getFile());
       url = new URL("jar:" + url + '!' + ref);
     } else {
       url = StdXMLReader.class.getResource(ref);
     }
   }
   currentReader.publicId = publicID;
   currentReader.systemId = url;
   final StringBuilder charsRead = new StringBuilder();
   final Reader reader = this.stream2reader(url.openStream(), charsRead);
   if (charsRead.length() == 0) {
     return reader;
   }
   final String charsReadStr = charsRead.toString();
   final PushbackReader pbreader = new PushbackReader(reader, charsReadStr.length());
   for (int i = charsReadStr.length() - 1; i >= 0; i--) {
     pbreader.unread(charsReadStr.charAt(i));
   }
   return pbreader;
 }
Exemple #6
0
  protected Set<Class> processJarUrl(URL url, String basepath, Class clazz) throws IOException {
    Set<Class> set = new HashSet<Class>();
    String path = url.getFile().substring(5, url.getFile().indexOf("!"));
    JarFile jar = new JarFile(path);

    for (Enumeration entries = jar.entries(); entries.hasMoreElements(); ) {
      JarEntry entry = (JarEntry) entries.nextElement();
      if (entry.getName().startsWith(basepath) && entry.getName().endsWith(".class")) {
        try {
          String name = entry.getName();
          // Ignore anonymous
          // TODO RM what about the other anonymous classes like $2, $3 ?
          if (name.contains("$1")) {
            continue;
          }
          URL classURL = classLoader.getResource(name);
          ClassReader reader = new ClassReader(classURL.openStream());
          ClassScanner visitor = getScanner(clazz);
          reader.accept(visitor, 0);
          if (visitor.isMatch()) {
            Class c = loadClass(visitor.getClassName());
            if (c != null) {
              set.add(c);
            }
          }
        } catch (Exception e) {
          if (logger.isDebugEnabled()) {
            Throwable t = ExceptionHelper.getRootException(e);
            logger.debug(String.format("%s: caused by: %s", e.toString(), t.toString()));
          }
        }
      }
    }
    return set;
  }
 public static Properties loadProperties(String fileName) {
   diag_println(DIAG_OFF, ".props : ", fileName);
   Properties props = new Properties();
   if (notNullOrEmpty(fileName)) {
     InputStream in = null;
     try {
       JarFile jarFile = null;
       if (isJarUri(fileName)) {
         URL url = new URL(fileName);
         url = new URL(url.getFile());
         String[] parts = url.getFile().split("!/");
         jarFile = new JarFile(new File(parts[0]));
         JarEntry jarEntry = jarFile.getJarEntry(parts[1]);
         in = jarFile.getInputStream(jarEntry);
       } else {
         File file = new File(fileName);
         if (file.isFile()) {
           in = new FileInputStream(file);
         } else {
           in = PluginUtils.class.getResourceAsStream(fileName);
         }
       }
       props.load(in);
       if (jarFile != null) jarFile.close();
     } catch (Exception e) {
       Log.log(Log.ERROR, PluginUtils.class + ".loadProperties", e);
     } finally {
       IOUtilities.closeQuietly((Closeable) in);
     }
   }
   return props;
 }
Exemple #8
0
 /**
  * Comparison that does not consider Ref.
  *
  * @param url1 the url1
  * @param url2 the url2
  * @return true, if successful
  */
 public static boolean sameNoRefURL(URL url1, URL url2) {
   return Objects.equals(url1.getHost(), url2.getHost())
       && Objects.equals(url1.getProtocol(), url2.getProtocol())
       && (url1.getPort() == url2.getPort())
       && Objects.equals(url1.getFile(), url2.getFile())
       && Objects.equals(url1.getUserInfo(), url2.getUserInfo());
 }
  /**
   * Gets a resource as InputStream.
   *
   * @param fileName The path and name of the file relative from the working directory.
   * @return The resource as InputStream.
   * @throws FileNotFoundException Thrown if the resource cannot be located.
   */
  public static File getResourceAsFile(final String fileName, ClassLoader classLoader)
      throws FileNotFoundException {
    URL url = classLoader.getResource(resolveFileName(fileName));

    // Maybe it's in a WAR file
    if (url == null) {
      url = classLoader.getResource(resolveFileName("WEB-INF/classes/" + fileName));
    }

    File file = null;
    if (url != null) {
      logger.debug("Resource found: " + url.getFile());
      try {
        // Decode necessary for windows paths
        file = new File(URLDecoder.decode(url.getFile(), "cp1253"));
      } catch (UnsupportedEncodingException e) {
        logger.warn(e);
      }
    }

    if (file == null) {

      logger.debug("Resource not found, getting file.");

      file = new File(fileName);
      if (!file.exists()) {
        throw new FileNotFoundException("File '" + fileName + "' not found.");
      }
    }
    return file;
  }
Exemple #10
0
 private URL targetURL(URL base, String name) throws MalformedURLException {
   StringBuffer sb = new StringBuffer(base.getFile().length() + name.length());
   sb.append(base.getFile());
   sb.append(name);
   String file = sb.toString();
   return new URL(base.getProtocol(), base.getHost(), base.getPort(), file, null);
 }
Exemple #11
0
  public static File webget(String urlString, String filename)
      throws MalformedURLException, IOException, FileNotFoundException {
    InputStream in = null;
    FileOutputStream out = null;
    URL url = new URL(urlString);
    File destFile = null;
    if (filename == null) {
      String inputStr = url.getFile();
      destFile = new File(inputStr.replaceAll(".*[\\/](.*)$", "$1"));
    } else if (new File(filename).isDirectory()) {
      String inputStr = url.getFile();
      destFile = new File(filename + "/" + inputStr.replaceAll(".*[\\/](.*)$", "$1"));
    } else {
      destFile = new File(filename);
    }

    URLConnection conn = url.openConnection();
    long len = conn.getContentLength();
    String contentLen;
    if (len < 0) {
      contentLen = "Unknown Length";
    } else {
      contentLen = len + " byte" + ((len > 1) ? "s" : "");
    }
    System.out.println("Downloading " + destFile.getName() + " " + contentLen);
    in = url.openStream();
    out = new FileOutputStream(destFile);
    copyStream(in, out, len);
    System.out.println("Download completed.");

    return destFile;
  }
Exemple #12
0
  public static File toFile(final URL url) {
    if ("jar".equals(url.getProtocol())) {
      try {
        final String spec = url.getFile();

        int separator = spec.indexOf('!');
        /*
         * REMIND: we don't handle nested JAR URLs
         */
        if (separator == -1) throw new MalformedURLException("no ! found in jar url spec:" + spec);

        return toFile(new URL(spec.substring(0, separator++)));
      } catch (MalformedURLException e) {
        throw new IllegalStateException(e);
      }
    } else if ("file".equals(url.getProtocol())) {
      String path = decode(url.getFile());
      if (path.endsWith("!")) {
        path = path.substring(0, path.length() - 1);
      }
      return new File(path);
    } else {
      throw new IllegalArgumentException("Unsupported URL scheme: " + url.toExternalForm());
    }
  }
Exemple #13
0
  private String getFileWithNormalizedPath(URL url) throws MalformedURLException {
    String file;

    if (hasNormalizablePathPattern.matcher(url.getPath()).find()) {
      // only normalize the path if there is something to normalize
      // to avoid needless work
      try {
        file = url.toURI().normalize().toURL().getFile();
        // URI.normalize() does not normalize leading dot segments,
        // see also http://tools.ietf.org/html/rfc3986#section-5.2.4
        int start = 0;
        while (file.startsWith("/../", start)) {
          start += 3;
        }
        if (start > 0) {
          file = file.substring(start);
        }
      } catch (URISyntaxException e) {
        file = url.getFile();
      }
    } else {
      file = url.getFile();
    }

    // if path is empty return a single slash
    if (file.isEmpty()) {
      file = "/";
    }

    return file;
  }
  private static File extract(URL url) throws IOException {
    File localFile;
    if ("file".equals(url.getProtocol()))
      localFile = new File(URLDecoder.decode(url.getFile(), "UTF-8"));
    else {
      File f = new File(System.getProperty("user.home"));
      f = new File(f, ".jnaerator");
      f = new File(f, "extractedLibraries");
      if (!f.exists()) f.mkdirs();

      localFile = new File(f, new File(url.getFile()).getName());
      URLConnection c = url.openConnection();
      if (localFile.exists() && localFile.lastModified() > c.getLastModified()) {
        c.getInputStream().close();
      } else {
        System.out.println("Extracting " + url);
        InputStream in = c.getInputStream();
        OutputStream out = new FileOutputStream(localFile);
        int len;
        byte[] b = new byte[1024];
        while ((len = in.read(b)) > 0) out.write(b, 0, len);
        out.close();
        in.close();
      }
    }
    return localFile;
  }
  private static Instance[] initializeInstances(String dataFile, String labelFile) {

    // DataSetReader dsr = new CSVDataSetReader(new File("").getAbsolutePath() + "/src/opt/test/" +
    // dataFile);
    // DataSetReader lsr = new CSVDataSetReader(new File("").getAbsolutePath() + "/src/opt/test/" +
    // labelFile);

    URL d_path = IndepenentComponentAnalysisMyDataTest.class.getResource(dataFile);
    File df = new File(d_path.getFile());
    URL l_path = IndepenentComponentAnalysisMyDataTest.class.getResource(dataFile);
    File lf = new File(l_path.getFile());

    DataSetReader dsr = new CSVDataSetReader(df.toString());
    DataSetReader lsr = new CSVDataSetReader(lf.toString());
    DataSet ds;
    DataSet labs;

    try {
      ds = dsr.read();
      labs = lsr.read();
      Instance[] instances = ds.getInstances();
      Instance[] labels = labs.getInstances();

      //            for(int i = 0; i < instances.length; i++) {
      //                instances[i].setLabel(new Instance(labels[i].getData().get(0)));
      //            	//instances[i].setLabel(new Instance(labels[i].getData()));
      //            }

      return instances;
    } catch (Exception e) {
      System.out.println("Failed to read input file");
      return null;
    }
  }
  @Override
  public Path resolve(Path path) {
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    if (cl != null) {
      String spath = path.toString();
      String substituted = FILE_SEP == '/' ? spath : spath.replace(FILE_SEP, '/');
      URL url = cl.getResource(substituted);
      if (url != null) {
        if (FILE_SEP == '/') {
          // *nix - a bit quicker than pissing around with URIs
          String sfile = url.getFile();
          if (sfile != null) {
            return Paths.get(url.getFile());
          }
        } else {
          // E.g. windows
          // See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4701321

          try {
            URI uri = url.toURI();
            if (uri.isOpaque()) {
              return Paths.get(url.getPath());
            } else {
              return Paths.get(uri);
            }
          } catch (Exception exc) {
            throw new VertxException(exc);
          }
        }
      }
    }
    return path;
  }
 /**
  * Returns the groovy-all-*.jar that is used in the Eclipse project. We know there should only be
  * one specified in the header for org.codehaus.groovy right now.
  *
  * @return Returns the names of the jars that are exported by the org.codehaus.groovy project.
  * @throws BundleException
  */
 public static URL getExportedGroovyAllJar() {
   try {
     Bundle groovyBundle = CompilerUtils.getActiveGroovyBundle();
     if (groovyBundle == null) {
       throw new RuntimeException("Could not find groovy bundle");
     }
     Enumeration<URL> enu = groovyBundle.findEntries("lib", "groovy-all-*.jar", false);
     if (enu == null) {
       // in some versions of the plugin, the groovy-all jar is in the base directory of the
       // plugins
       enu = groovyBundle.findEntries("", "groovy-all-*.jar", false);
     }
     while (enu.hasMoreElements()) {
       URL jar = enu.nextElement();
       if (jar.getFile().indexOf("-sources") == -1
           && jar.getFile().indexOf("-javadoc") == -1
           && jar.getFile().indexOf("-eclipse") == -1) {
         // remove the "reference:/" protocol
         jar = resolve(jar);
         return jar;
       }
     }
   } catch (IOException e) {
     throw new RuntimeException(e);
   }
   throw new RuntimeException("Could not find groovy all jar");
 }
 private String getCsvFilePath() {
   ClassLoader classLoader = getClass().getClassLoader();
   URL csvUrl = classLoader.getResource("category_mapping.csv");
   if (csvUrl == null || csvUrl.getFile() == null) {
     throw new RuntimeException("Bad path to category_mapping.csv");
   }
   return csvUrl.getFile();
 }
Exemple #19
0
 public static String findNameOfFileInURL(URL u) {
   if (u.getQuery() != null) {
     Matcher m = p.matcher(u.getQuery());
     if (m.find()) {
       return m.group(2);
     }
   }
   return u.getFile().substring(u.getFile().lastIndexOf('/') + 1);
 }
  @Test
  public void testAdvanced() throws IOException {
    final URL url = getClass().getResource("coffeeScript/advanced");

    final File testFolder = new File(url.getFile(), "test");
    final File expectedFolder = new File(url.getFile(), "expected");
    WroTestUtils.compareFromDifferentFoldersByExtension(
        testFolder, expectedFolder, "js", processor);
  }
  @Test
  public void shouldTransformFilesFromFolder() throws IOException {
    final URL url = getClass().getResource("dustjs");
    final File testFolder = new File(url.getFile(), "test");
    final File expectedFolder = new File(url.getFile(), "expected");

    WroTestUtils.compareFromDifferentFoldersByExtension(
        testFolder, expectedFolder, "js", processor);
  }
  /**
   * Downloads the given file specified via url to the given canonicalDestination.
   *
   * @param urlSource String
   * @param urlDestination String
   * @throws Exception
   */
  @Override
  public void downloadFile(String urlSource, String urlDestination) throws Exception {

    // sanity check
    if (urlSource == null
        || urlSource.length() == 0
        || urlDestination == null
        || urlDestination.length() == 0) {
      throw new IllegalArgumentException(
          "downloadFile(): urlSource or urlDestination argument is null...");
    }

    // URLs for given parameters
    URL source = new URL(urlSource);
    URL destination = new URL(urlDestination);

    // we have a compressed file
    if (GzipUtils.isCompressedFilename(urlSource)) {
      // downlod to temp destination
      File tempDestinationFile =
          org.apache.commons.io.FileUtils.getFile(
              org.apache.commons.io.FileUtils.getTempDirectory(),
              new File(source.getFile()).getName());
      if (LOG.isInfoEnabled()) {
        LOG.info("downloadFile(), " + urlSource + ", this may take a while...");
      }
      org.apache.commons.io.FileUtils.copyURLToFile(source, tempDestinationFile);
      if (LOG.isInfoEnabled()) {
        LOG.info("downloadFile(), gunzip: we have compressed file, decompressing...");
      }
      // decompress the file
      gunzip(tempDestinationFile.getCanonicalPath());
      if (LOG.isInfoEnabled()) {
        LOG.info("downloadFile(), gunzip complete...");
      }
      // move temp/decompressed file to final destination
      File destinationFile = new File(destination.getFile());
      if (destinationFile.exists()) {
        org.apache.commons.io.FileUtils.forceDelete(destinationFile);
      }
      org.apache.commons.io.FileUtils.moveFile(
          org.apache.commons.io.FileUtils.getFile(
              GzipUtils.getUncompressedFilename(tempDestinationFile.getCanonicalPath())),
          destinationFile);

      // lets cleanup after ourselves - remove compressed file
      tempDestinationFile.delete();
    }
    // uncompressed file, download directry to urlDestination
    else {
      if (LOG.isInfoEnabled()) {
        LOG.info("downloadFile(), " + urlSource + ", this may take a while...");
      }
      org.apache.commons.io.FileUtils.copyURLToFile(
          source, org.apache.commons.io.FileUtils.getFile(destination.getFile()));
    }
  }
  @Test
  public void testFromFolder() throws IOException {
    final ResourcePostProcessor processor = new MultiLineCommentStripperProcessor();

    final URL url = getClass().getResource("multiline");

    final File testFolder = new File(url.getFile(), "test");
    final File expectedFolder = new File(url.getFile(), "expected");
    WroTestUtils.compareFromDifferentFoldersByExtension(testFolder, expectedFolder, "*", processor);
  }
  @Test
  public void testFromFolder() throws Exception {
    final ResourcePostProcessor processor = new RhinoLessCssProcessor();
    final URL url = getClass().getResource("lesscss");

    final File testFolder = new File(url.getFile(), "test");
    final File expectedFolder = new File(url.getFile(), "expected");
    WroTestUtils.compareFromDifferentFoldersByExtension(
        testFolder, expectedFolder, "css", processor);
  }
Exemple #25
0
  /** Ignored because it fails when running the test from command line. */
  @Test
  public void testFromFolder() throws Exception {
    final ResourcePreProcessor processor = new WroManagerProcessor();
    final URL url = getClass().getResource("wroManager");

    final File testFolder = new File(url.getFile(), "test");
    final File expectedFolder = new File(url.getFile(), "expected");
    WroTestUtils.compareFromDifferentFoldersByExtension(
        testFolder, expectedFolder, "js", processor);
  }
  /* this code is workaround for subtle bug/feature in JDK1.3.1 and 1.4,
  related to loading applets behind proxy */
  protected PermissionCollection getPermissions(CodeSource codesource) {
    PermissionCollection sysPerms = null;
    Policy policy =
        (Policy)
            AccessController.doPrivileged(
                new PrivilegedAction() {
                  public Object run() {
                    return Policy.getPolicy();
                  }
                });
    if (policy != null) sysPerms = policy.getPermissions(new CodeSource(null, null));
    else sysPerms = new Permissions();

    final PermissionCollection perms = sysPerms;
    if (base != null && base.getHost() != null)
      perms.add(new SocketPermission(base.getHost() + ":1-", "accept,connect,resolve"));
    URL url = codesource.getLocation();

    if (url.getProtocol().equals("file")) {

      String path = url.getFile().replace('/', File.separatorChar);

      if (!path.endsWith(File.separator)) {
        int endIndex = path.lastIndexOf(File.separatorChar);
        if (endIndex != -1) {
          path = path.substring(0, endIndex + 1) + "-";
          perms.add(new FilePermission(path, "read"));
        }
      }
      perms.add(new SocketPermission("localhost", "connect,accept"));
      AccessController.doPrivileged(
          new PrivilegedAction() {
            public Object run() {
              try {
                String host = InetAddress.getLocalHost().getHostName();
                perms.add(new SocketPermission(host, "connect,accept"));
              } catch (UnknownHostException uhe) {
              }
              return null;
            }
          });

      if (base.getProtocol().equals("file")) {
        String bpath = base.getFile().replace('/', File.separatorChar);
        if (bpath.endsWith(File.separator)) {
          bpath += "-";
        }
        perms.add(new FilePermission(bpath, "read"));
      }
    }
    // for (Enumeration e=perms.elements();e.hasMoreElements();)
    // System.err.println("p="+e.nextElement());
    return perms;
  }
  /**
   * Searches the class path and local paths to find the config file.
   *
   * @param path path to find. if it starts with / then it's absolute path.
   * @return File or null if not found at all.
   */
  public static File findConfigFile(String path) {
    ClassLoader cl = PropertiesUtil.class.getClassLoader();
    URL url = cl.getResource(path);
    if (url != null) {
      return new File(url.getFile());
    }

    url = ClassLoader.getSystemResource(path);
    if (url != null) {
      return new File(url.getFile());
    }

    File file = new File(path);
    if (file.exists()) {
      return file;
    }

    String newPath = "conf" + (path.startsWith(File.separator) ? "" : "/") + path;
    url = ClassLoader.getSystemResource(newPath);
    if (url != null) {
      return new File(url.getFile());
    }

    url = cl.getResource(newPath);
    if (url != null) {
      return new File(url.getFile());
    }

    newPath = "conf" + (path.startsWith(File.separator) ? "" : File.separator) + path;
    file = new File(newPath);
    if (file.exists()) {
      return file;
    }

    newPath = System.getenv("CATALINA_HOME");
    if (newPath == null) {
      newPath = System.getenv("CATALINA_BASE");
    }

    if (newPath == null) {
      newPath = System.getProperty("catalina.home");
    }

    if (newPath == null) {
      return null;
    }

    file = new File(newPath + File.separator + "conf" + File.separator + path);
    if (file.exists()) {
      return file;
    }

    return null;
  }
  @Before
  public void setUp() {
    try {
      URL res = this.getClass().getClassLoader().getResource("toolspecs");
      // use the file toolspec xml as the input file too (for this test)
      toolspecsDir = res.getFile();
      repo = new LocalToolRepository(res.getFile());

    } catch (IOException ex) {
      fail(ex.getMessage());
    }
  }
  public HelloServlet() {
    super();
    URL url = HelloServlet.class.getResource("HelloServlet.class");
    if (url != null) {
      System.out.println("]]]]]]]]]]]]]]]]]] HelloServlet :" + url);
      System.out.println("]]]]]]]]]]]]]]]]]] HelloServlet :" + url.getFile());
      System.out.println("]]]]]]]]]]]]]]]]]] HelloServlet :" + new File(url.getFile()).exists());
      System.out.println("]]]]]]]]]]]]]]]]]] HelloServlet :" + url.toExternalForm());
    } else {

    }
  }
  /**
   * Create a script from an URL.
   *
   * @param url representing a script source code.
   * @param parameters execution arguments.
   * @throws InvalidScriptException if the creation fails.
   */
  public Script(URL url, Serializable[] parameters) throws InvalidScriptException {
    this.scriptEngineLookup = FileUtils.getExtension(url.getFile());

    try {
      storeScript(url);
    } catch (IOException e) {
      throw new InvalidScriptException("Unable to read script : " + url.getPath(), e);
    }

    this.id = url.toExternalForm();
    this.parameters = parameters;
    this.scriptName = url.getFile();
  }