View Javadoc

1   /**
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  package org.apache.hadoop.hbase.util;
19  
20  import java.io.File;
21  import java.io.IOException;
22  import java.net.MalformedURLException;
23  import java.net.URL;
24  import java.util.HashMap;
25  
26  import org.apache.commons.logging.Log;
27  import org.apache.commons.logging.LogFactory;
28  import org.apache.hadoop.hbase.classification.InterfaceAudience;
29  import org.apache.hadoop.conf.Configuration;
30  import org.apache.hadoop.fs.FileStatus;
31  import org.apache.hadoop.fs.FileSystem;
32  import org.apache.hadoop.fs.Path;
33  
34  /**
35   * This is a class loader that can load classes dynamically from new
36   * jar files under a configured folder. The paths to the jar files are
37   * converted to URLs, and URLClassLoader logic is actually used to load
38   * classes. This class loader always uses its parent class loader
39   * to load a class at first. Only if its parent class loader
40   * can not load a class, we will try to load it using the logic here.
41   * <p>
42   * The configured folder can be a HDFS path. In this case, the jar files
43   * under that folder will be copied to local at first under ${hbase.local.dir}/jars/.
44   * The local copy will be updated if the remote copy is updated, according to its
45   * last modified timestamp.
46   * <p>
47   * We can't unload a class already loaded. So we will use the existing
48   * jar files we already know to load any class which can't be loaded
49   * using the parent class loader. If we still can't load the class from
50   * the existing jar files, we will check if any new jar file is added,
51   * if so, we will load the new jar file and try to load the class again.
52   * If still failed, a class not found exception will be thrown.
53   * <p>
54   * Be careful in uploading new jar files and make sure all classes
55   * are consistent, otherwise, we may not be able to load your
56   * classes properly.
57   */
58  @InterfaceAudience.Private
59  public class DynamicClassLoader extends ClassLoaderBase {
60    private static final Log LOG =
61        LogFactory.getLog(DynamicClassLoader.class);
62  
63    // Dynamic jars are put under ${hbase.local.dir}/jars/
64    private static final String DYNAMIC_JARS_DIR = File.separator
65      + "jars" + File.separator;
66  
67    private static final String DYNAMIC_JARS_DIR_KEY = "hbase.dynamic.jars.dir";
68  
69    private static final String DYNAMIC_JARS_OPTIONAL_CONF_KEY = "hbase.use.dynamic.jars";
70    private static final boolean DYNAMIC_JARS_OPTIONAL_DEFAULT = true;
71  
72    private boolean useDynamicJars;
73  
74    private File localDir;
75  
76    // FileSystem of the remote path, set only if remoteDir != null
77    private FileSystem remoteDirFs;
78    private Path remoteDir;
79  
80    // Last modified time of local jars
81    private HashMap<String, Long> jarModifiedTime;
82  
83    /**
84     * Creates a DynamicClassLoader that can load classes dynamically
85     * from jar files under a specific folder.
86     *
87     * @param conf the configuration for the cluster.
88     * @param parent the parent ClassLoader to set.
89     */
90    public DynamicClassLoader(
91        final Configuration conf, final ClassLoader parent) {
92      super(parent);
93  
94      useDynamicJars = conf.getBoolean(
95          DYNAMIC_JARS_OPTIONAL_CONF_KEY, DYNAMIC_JARS_OPTIONAL_DEFAULT);
96  
97      if (useDynamicJars) {
98        initTempDir(conf);
99      }
100   }
101 
102   // FindBugs: Making synchronized to avoid IS2_INCONSISTENT_SYNC complaints about
103   // remoteDirFs and jarModifiedTime being part synchronized protected.
104   private synchronized void initTempDir(final Configuration conf) {
105     jarModifiedTime = new HashMap<String, Long>();
106     String localDirPath = conf.get(
107       LOCAL_DIR_KEY, DEFAULT_LOCAL_DIR) + DYNAMIC_JARS_DIR;
108     localDir = new File(localDirPath);
109     if (!localDir.mkdirs() && !localDir.isDirectory()) {
110       throw new RuntimeException("Failed to create local dir " + localDir.getPath()
111         + ", DynamicClassLoader failed to init");
112     }
113 
114     String remotePath = conf.get(DYNAMIC_JARS_DIR_KEY);
115     if (remotePath == null || remotePath.equals(localDirPath)) {
116       remoteDir = null;  // ignore if it is the same as the local path
117     } else {
118       remoteDir = new Path(remotePath);
119       try {
120         remoteDirFs = remoteDir.getFileSystem(conf);
121       } catch (IOException ioe) {
122         LOG.warn("Failed to identify the fs of dir "
123           + remoteDir + ", ignored", ioe);
124         remoteDir = null;
125       }
126     }
127   }
128 
129   @Override
130   public Class<?> loadClass(String name)
131       throws ClassNotFoundException {
132     try {
133       return parent.loadClass(name);
134     } catch (ClassNotFoundException e) {
135       if (LOG.isDebugEnabled()) {
136         LOG.debug("Class " + name + " not found - using dynamical class loader");
137       }
138 
139       if (useDynamicJars) {
140         return tryRefreshClass(name);
141       }
142       throw e;
143     }
144   }
145 
146 
147   private Class<?> tryRefreshClass(String name)
148       throws ClassNotFoundException {
149     synchronized (getClassLoadingLock(name)) {
150         // Check whether the class has already been loaded:
151         Class<?> clasz = findLoadedClass(name);
152         if (clasz != null) {
153           if (LOG.isDebugEnabled()) {
154             LOG.debug("Class " + name + " already loaded");
155           }
156         }
157         else {
158           try {
159             if (LOG.isDebugEnabled()) {
160               LOG.debug("Finding class: " + name);
161             }
162             clasz = findClass(name);
163           } catch (ClassNotFoundException cnfe) {
164             // Load new jar files if any
165             if (LOG.isDebugEnabled()) {
166               LOG.debug("Loading new jar files, if any");
167             }
168             loadNewJars();
169 
170             if (LOG.isDebugEnabled()) {
171               LOG.debug("Finding class again: " + name);
172             }
173             clasz = findClass(name);
174           }
175         }
176         return clasz;
177       }
178   }
179 
180   private synchronized void loadNewJars() {
181     // Refresh local jar file lists
182     for (File file: localDir.listFiles()) {
183       String fileName = file.getName();
184       if (jarModifiedTime.containsKey(fileName)) {
185         continue;
186       }
187       if (file.isFile() && fileName.endsWith(".jar")) {
188         jarModifiedTime.put(fileName, Long.valueOf(file.lastModified()));
189         try {
190           URL url = file.toURI().toURL();
191           addURL(url);
192         } catch (MalformedURLException mue) {
193           // This should not happen, just log it
194           LOG.warn("Failed to load new jar " + fileName, mue);
195         }
196       }
197     }
198 
199     // Check remote files
200     FileStatus[] statuses = null;
201     if (remoteDir != null) {
202       try {
203         statuses = remoteDirFs.listStatus(remoteDir);
204       } catch (IOException ioe) {
205         LOG.warn("Failed to check remote dir status " + remoteDir, ioe);
206       }
207     }
208     if (statuses == null || statuses.length == 0) {
209       return; // no remote files at all
210     }
211 
212     for (FileStatus status: statuses) {
213       if (status.isDirectory()) continue; // No recursive lookup
214       Path path = status.getPath();
215       String fileName = path.getName();
216       if (!fileName.endsWith(".jar")) {
217         if (LOG.isDebugEnabled()) {
218           LOG.debug("Ignored non-jar file " + fileName);
219         }
220         continue; // Ignore non-jar files
221       }
222       Long cachedLastModificationTime = jarModifiedTime.get(fileName);
223       if (cachedLastModificationTime != null) {
224         long lastModified = status.getModificationTime();
225         if (lastModified < cachedLastModificationTime.longValue()) {
226           // There could be some race, for example, someone uploads
227           // a new one right in the middle the old one is copied to
228           // local. We can check the size as well. But it is still
229           // not guaranteed. This should be rare. Most likely,
230           // we already have the latest one.
231           // If you are unlucky to hit this race issue, you have
232           // to touch the remote jar to update its last modified time
233           continue;
234         }
235       }
236       try {
237         // Copy it to local
238         File dst = new File(localDir, fileName);
239         remoteDirFs.copyToLocalFile(path, new Path(dst.getPath()));
240         jarModifiedTime.put(fileName, Long.valueOf(dst.lastModified()));
241         URL url = dst.toURI().toURL();
242         addURL(url);
243       } catch (IOException ioe) {
244         LOG.warn("Failed to load new jar " + fileName, ioe);
245       }
246     }
247   }
248 }