@Override public void close() throws IOException { isClosed = true; super.close(); } }
@Override public void close() throws IOException { isClosed = true; super.close(); } }
@Override public void close() throws IOException { super.close(); }
/** * Release class loader that was used for class loading and attempt to delete all extracted jars. * If deletion will not succeed, they will be deleted on JVM exit. * * @throws IOException */ @Override public void close() throws IOException { if ( jarsClassLoader != null ) { jarsClassLoader.close(); } extractedFiles.forEach( File::delete ); extractedFiles.clear(); }
@Override public void closeURLClassLoader(final String instanceIdentifier, final ClassLoader classLoader) { if ((classLoader instanceof URLClassLoader)) { final URLClassLoader urlClassLoader = (URLClassLoader) classLoader; try { urlClassLoader.close(); } catch (IOException e) { logger.warn("Unable to close URLClassLoader for " + instanceIdentifier); } } }
@Override protected void tearDown() throws Exception { classReloader.close(); Thread.currentThread().setContextClassLoader(oldClassLoader); System.clearProperty("guava.concurrent.generate_cancellation_cause"); }
/** * Closes class loader logging possible checked exception. * * @param clsLdr Class loader. If it's {@code null} - it's no-op. * @param log Logger to log possible checked exception with (optional). */ public static void close(@Nullable URLClassLoader clsLdr, @Nullable IgniteLogger log) { if (clsLdr != null) { try { clsLdr.close(); } catch (Exception e) { warn(log, "Failed to close resource: " + e.getMessage()); } } }
/** * */ @Override public void close() throws IOException { logger.info("Closing Spring Application Context"); this.applicationContext.close(); if (logger.isInfoEnabled()) { logger.info("Closing " + this.getClass().getClassLoader()); } ((URLClassLoader) this.getClass().getClassLoader()).close(); logger.info("Successfully closed Spring Application Context and its ClassLoader."); } }
private void deleteAllLocalResources() { try { executorClassloader.close(); } catch (Exception ex) { LOG.info("Failed to close the classloader", ex.getMessage()); } resourcesByFn.clear(); for (RefCountedResource rcr : localFiles.values()) { for (FunctionResource fr : rcr.resources) { // We ignore refcounts (and errors) for now. File file = new File(fr.getResourceURI()); try { if (!file.delete()) { LOG.info("Failed to delete " + file); } } catch (Exception ex) { LOG.info("Failed to delete " + file + ": " + ex.getMessage()); } } } }
/** * Closes this GroovyClassLoader and clears any caches it maintains. * <p> * No use should be made of this instance after this method is * invoked. Any classes that are already loaded are still accessible. * * @throws IOException * @see URLClassLoader#close() * @see #clearCache() * @since 2.5.0 */ @Override public void close() throws IOException { super.close(); clearCache(); }
@Override public void close() throws Exception { urlClassLoader.close(); urlClassLoader = null; recordCleanup(); attemptToCleanupMaxRetryTimes(); } }
public void reset() { lock.writeLock().lock(); try { pluginTypes.clear(); extensions.clear(); pluginMap.clear(); classLoaderMap.clear(); classLoaderGroupsMap.clear(); folderBasedClassLoaderMap.clear(); inverseClassLoaderLookup.forEach( ( key, value ) -> { try { key.close(); } catch ( IOException e ) { e.printStackTrace(); } } ); inverseClassLoaderLookup.clear(); categoryMap.clear(); parentClassloaderPatternMap.clear(); listeners.clear(); JarFileCache.getInstance().clear(); } finally { lock.writeLock().unlock(); } }
} finally { try { context.classLoader.close(); } catch (IOException ignore) {
ucl.close(); } catch ( IOException e ) { e.printStackTrace();
@Override protected void stopContext() throws Exception { stopWebapp(); try { for (int i=_configurations.size();i-->0;) _configurations.get(i).deconfigure(this); if (_metadata != null) _metadata.clear(); _metadata=new MetaData(); } finally { if (_ownClassLoader) { ClassLoader loader = getClassLoader(); if (loader != null && loader instanceof URLClassLoader) ((URLClassLoader)loader).close(); setClassLoader(null); } setAvailable(true); _unavailableException=null; } }
/** * {@inheritDoc} */ @Override public void close() { try { classLoader.close(); } catch (IOException e) { throw new UncheckedIOException(e); } } }
/** Closes all cached classloaders. */ public static void clear() { List<URLClassLoader> toDelete; synchronized (instance) { toDelete = new ArrayList<>(instance.cache.values()); instance.cache.clear(); } for (URLClassLoader classLoader : toDelete) { try { classLoader.close(); } catch (IOException e) { throw ThrowingEx.asRuntime(e); } } }
@Override public void close() throws IOException { try { urlClassLoader.close(); } finally { try { zipFile.close(); } finally { jarFile.close(); } } }
@Override public void dispose() { registeredClassLoaders.stream().map(c -> c.unfilteredClassLoader).forEach(this::disposeClassLoader); registeredClassLoaders.clear(); descriptorMapping.forEach((descriptor, classloader) -> { try { classloader.close(); } catch (IOException e) { reportPossibleLeak(e, descriptor.getArtifactId()); } }); descriptorMapping.clear(); disposeClassLoader(ownerClassLoader); super.dispose(); }
@Override public void dispose() { descriptorMapping.forEach((descriptor, classloader) -> { try { classloader.close(); } catch (IOException e) { reportPossibleLeak(e, descriptor.getArtifactId()); } }); descriptorMapping.clear(); try { createResourceReleaserInstance().release(); } catch (Exception e) { LOGGER.error("Cannot create resource releaser instance", e); } super.dispose(); shutdownListeners(); }