1 /*
   2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.istack.internal.tools;
  27 
  28 import java.io.InputStream;
  29 import java.io.ByteArrayOutputStream;
  30 import java.io.Closeable;
  31 import java.io.File;
  32 import java.io.IOException;
  33 import java.net.JarURLConnection;
  34 import java.net.URISyntaxException;
  35 import java.net.URL;
  36 import java.net.MalformedURLException;
  37 import java.net.URLConnection;
  38 import java.util.Collections;
  39 import java.util.Enumeration;
  40 import java.util.HashSet;
  41 import java.util.Set;
  42 import java.util.jar.JarFile;
  43 import java.util.logging.Level;
  44 import java.util.logging.Logger;
  45 
  46 /**
  47  * Load classes/resources from a side folder, so that
  48  * classes of the same package can live in a single jar file.
  49  *
  50  * <p>
  51  * For example, with the following jar file:
  52  * <pre>
  53  *  /
  54  *  +- foo
  55  *     +- X.class
  56  *  +- bar
  57  *     +- X.class
  58  * </pre>
  59  * <p>
  60  * {@link ParallelWorldClassLoader}("foo/") would load {@code X.class} from
  61  * {@code /foo/X.class} (note that X is defined in the root package, not
  62  * {@code foo.X}.
  63  *
  64  * <p>
  65  * This can be combined with  {@link MaskingClassLoader} to mask classes which are loaded by the parent
  66  * class loader so that the child class loader
  67  * classes living in different folders are loaded
  68  * before the parent class loader loads classes living the jar file publicly
  69  * visible
  70  * For example, with the following jar file:
  71  * <pre>
  72  *  /
  73  *  +- foo
  74  *     +- X.class
  75  *  +- bar
  76  *     +-foo
  77  *        +- X.class
  78  * </pre>
  79  * <p>
  80  * {@link ParallelWorldClassLoader}(MaskingClassLoader.class.getClassLoader())
  81  * would load {@code foo.X.class}  from
  82  * {@code /bar/foo.X.class} not the {@code foo.X.class}
  83  * in the publicly visible place in the jar file, thus
  84  * masking the parent classLoader from loading the class from {@code foo.X.class}
  85  * (note that X is defined in the  package foo, not
  86  * {@code bar.foo.X}.
  87  *
  88  * @author Kohsuke Kawaguchi
  89  */
  90 public class ParallelWorldClassLoader extends ClassLoader implements Closeable {
  91 
  92     /**
  93      * Strings like "prefix/", "abc/", or "" to indicate
  94      * classes should be loaded normally.
  95      */
  96     private final String prefix;
  97     private final Set<JarFile> jars;
  98 
  99     public ParallelWorldClassLoader(ClassLoader parent,String prefix) {
 100         super(parent);
 101         this.prefix = prefix;
 102         jars = Collections.synchronizedSet(new HashSet<JarFile>());
 103     }
 104 
 105     protected Class findClass(String name) throws ClassNotFoundException {
 106 
 107         StringBuffer sb = new StringBuffer(name.length()+prefix.length()+6);
 108         sb.append(prefix).append(name.replace('.','/')).append(".class");
 109 
 110         URL u  = getParent().getResource(sb.toString());
 111         if (u == null) {
 112             throw new ClassNotFoundException(name);
 113         }
 114 
 115         InputStream is = null;
 116         URLConnection con = null;
 117 
 118         try {
 119             con = u.openConnection();
 120             is = con.getInputStream();
 121         } catch (IOException ioe) {
 122             throw new ClassNotFoundException(name);
 123         }
 124 
 125         if (is==null)
 126             throw new ClassNotFoundException(name);
 127 
 128         try {
 129             ByteArrayOutputStream baos = new ByteArrayOutputStream();
 130             byte[] buf = new byte[1024];
 131             int len;
 132             while((len=is.read(buf))>=0)
 133                 baos.write(buf,0,len);
 134 
 135             buf = baos.toByteArray();
 136             int packIndex = name.lastIndexOf('.');
 137             if (packIndex != -1) {
 138                 String pkgname = name.substring(0, packIndex);
 139                 // Check if package already loaded.
 140                 Package pkg = getPackage(pkgname);
 141                 if (pkg == null) {
 142                     definePackage(pkgname, null, null, null, null, null, null, null);
 143                 }
 144             }
 145             return defineClass(name,buf,0,buf.length);
 146         } catch (IOException e) {
 147             throw new ClassNotFoundException(name,e);
 148         } finally {
 149             try {
 150                 if (con != null && con instanceof JarURLConnection) {
 151                     jars.add(((JarURLConnection) con).getJarFile());
 152                 }
 153             } catch (IOException ioe) {
 154                 //ignore
 155             }
 156             if (is != null) {
 157                 try {
 158                     is.close();
 159                 } catch (IOException ioe) {
 160                     //ignore
 161                 }
 162             }
 163         }
 164     }
 165 
 166     @Override
 167     protected URL findResource(String name) {
 168         URL u = getParent().getResource(prefix + name);
 169         if (u != null) {
 170             try {
 171                 jars.add(new JarFile(new File(toJarUrl(u).toURI())));
 172             } catch (URISyntaxException ex) {
 173                 Logger.getLogger(ParallelWorldClassLoader.class.getName()).log(Level.WARNING, null, ex);
 174             } catch (IOException ex) {
 175                 Logger.getLogger(ParallelWorldClassLoader.class.getName()).log(Level.WARNING, null, ex);
 176             } catch (ClassNotFoundException ex) {
 177                 //ignore - not a jar
 178             }
 179         }
 180         return u;
 181     }
 182 
 183     @Override
 184     protected Enumeration<URL> findResources(String name) throws IOException {
 185         Enumeration<URL> en = getParent().getResources(prefix + name);
 186         while (en.hasMoreElements()) {
 187             try {
 188                 jars.add(new JarFile(new File(toJarUrl(en.nextElement()).toURI())));
 189             } catch (URISyntaxException ex) {
 190                 //should not happen
 191                 Logger.getLogger(ParallelWorldClassLoader.class.getName()).log(Level.WARNING, null, ex);
 192             } catch (IOException ex) {
 193                 Logger.getLogger(ParallelWorldClassLoader.class.getName()).log(Level.WARNING, null, ex);
 194             } catch (ClassNotFoundException ex) {
 195                 //ignore - not a jar
 196             }
 197         }
 198         return en;
 199     }
 200 
 201     public synchronized void close() throws IOException {
 202         for (JarFile jar : jars) {
 203             jar.close();
 204         }
 205     }
 206 
 207     /**
 208      * Given the URL inside jar, returns the URL to the jar itself.
 209      */
 210     public static URL toJarUrl(URL res) throws ClassNotFoundException, MalformedURLException {
 211         String url = res.toExternalForm();
 212         if(!url.startsWith("jar:"))
 213             throw new ClassNotFoundException("Loaded outside a jar "+url);
 214         url = url.substring(4); // cut off jar:
 215         url = url.substring(0,url.lastIndexOf('!'));    // cut off everything after '!'
 216         url = url.replaceAll(" ", "%20"); // support white spaces in path
 217         return new URL(url);
 218     }
 219 }
--- EOF ---