private File unpack200(String pluginKey, File compressedFile) { LOGGER.debug("Unpacking plugin {}", pluginKey); File jar = newTempFile(); try (InputStream input = new GZIPInputStream(new BufferedInputStream(FileUtils.openInputStream(compressedFile))); JarOutputStream output = new JarOutputStream(new BufferedOutputStream(FileUtils.openOutputStream(jar)))) { Pack200.newUnpacker().unpack(input, output); } catch (IOException e) { throw new IllegalStateException(format("Fail to download plugin [%s]. Pack200 error.", pluginKey), e); } return jar; }
unpacker.unpack(tempFile, jos);
private File packAndUnpackJar(File source) throws IOException { File packed = temp.newFile(); try (JarInputStream in = new JarInputStream(new BufferedInputStream(Files.newInputStream(source.toPath()))); OutputStream out = new GZIPOutputStream(new BufferedOutputStream(Files.newOutputStream(packed.toPath())))) { Pack200.newPacker().pack(in, out); } File to = temp.newFile(); try (InputStream input = new GZIPInputStream(new BufferedInputStream(Files.newInputStream(packed.toPath()))); JarOutputStream output = new JarOutputStream(new BufferedOutputStream(Files.newOutputStream(to.toPath())))) { Pack200.newUnpacker().unpack(input, output); } catch (IOException e) { throw new IllegalStateException(e); } return to; }
unpacker.unpack(tempFile, jos);
JarOutputStream jos = new JarOutputStream(jarBytes); Pack200.newUnpacker().unpack(new ByteArrayInputStream(decompressed), jos);
/** * Unpacks a pack packFile. * * @param packFile the pack packFile meta-data * @param packInputStream the pack input stream * @param target the target * @throws IOException for any I/O error * @throws InstallerException for any installer exception */ @Override public void unpack(PackFile packFile, InputStream packInputStream, File target) throws IOException, InstallerException { InputStream in = IOUtils.buffer(packInputStream); JarOutputStream jarOut = null; try { jarOut = new JarOutputStream(getTarget(packFile, target)); Pack200.Unpacker unpacker = createPack200Unpacker(packFile); unpacker.unpack(in, jarOut); } finally { IOUtils.closeQuietly(jarOut); IOUtils.closeQuietly(in); } postCopy(packFile); }
public void close() throws IOException {} }; Pack200.newUnpacker().unpack(zin, out);
bos = new BufferedOutputStream(fos); jos = new JarOutputStream(bos); Pack200.newUnpacker().unpack(bis, jos); } finally { closeQuietly(jos);
/** * {@inheritDoc} */ public void unpack( File source, File destination, Map<String, String> props ) throws IOException { InputStream in = null; JarOutputStream out = null; try { in = new FileInputStream( source ); if ( isGzipped( source ) ) { in = new GZIPInputStream( in ); } in = new BufferedInputStream( in ); out = new JarOutputStream( new BufferedOutputStream( new FileOutputStream( destination ) ) ); Pack200.Unpacker unpacker = Pack200.newUnpacker(); unpacker.properties().putAll( props ); unpacker.unpack( in, out ); } finally { IOUtil.close( in ); IOUtil.close( out ); } }
private Pack200CompressorInputStream(final InputStream in, final File f, final Pack200Strategy mode, final Map<String, String> props) throws IOException { originalInput = in; streamBridge = mode.newStreamBridge(); try (final JarOutputStream jarOut = new JarOutputStream(streamBridge)) { final Pack200.Unpacker u = Pack200.newUnpacker(); if (props != null) { u.properties().putAll(props); } if (f == null) { u.unpack(new FilterInputStream(in) { @Override public void close() { // unpack would close this stream but we // want to give the user code more control } }, jarOut); } else { u.unpack(f, jarOut); } } }
private static Bundle installBundle(BundleContext context, String location) throws Exception { boolean pack = location.endsWith(PACK200_COMPRESSION); if (pack) { // Remove the pack classifier from the location path location = location.substring(0, location.length() - 8); pack = context.getBundle(location) == null; } if (pack) { final URL url = new URL(location + PACK200_COMPRESSION); final PipedInputStream in = new PipedInputStream(); try (final PipedOutputStream out = new PipedOutputStream(in)) { Thread t = new Thread(() -> { try (JarOutputStream jarStream = new JarOutputStream(out); GZIPInputStream gzStream = new GZIPInputStream(FileUtil.getAdaptedConnection(url).getInputStream())) { Unpacker unpacker = Pack200.newUnpacker(); unpacker.unpack(gzStream, jarStream); } catch (Exception e1) { System.err.println("Cannot install pack bundle: " + url); //$NON-NLS-1$ e1.printStackTrace(); } }); t.start(); return context.installBundle(location, in); } } return context.installBundle(location, FileUtil.getAdaptedConnection(new URI(location).toURL()).getInputStream()); }
private Pack200CompressorInputStream(final InputStream in, final File f, final Pack200Strategy mode, final Map<String, String> props) throws IOException { originalInput = in; streamBridge = mode.newStreamBridge(); try (final JarOutputStream jarOut = new JarOutputStream(streamBridge)) { final Pack200.Unpacker u = Pack200.newUnpacker(); if (props != null) { u.properties().putAll(props); } if (f == null) { u.unpack(new FilterInputStream(in) { @Override public void close() { // unpack would close this stream but we // want to give the user code more control } }, jarOut); } else { u.unpack(f, jarOut); } } }
private static byte[] unpack(byte[] data, File path) throws IOException { File output = new File(path.getAbsolutePath() + ".unpacked"); if (output.exists()) { output.delete(); } FileOutputStream jar = new FileOutputStream(output); JarOutputStream jos = new JarOutputStream(jar); Pack200.newUnpacker().unpack(new ByteArrayInputStream(data), jos); jos.close(); jar.close(); byte[] unpacked = Files.toByteArray(output); if (!DEBUG_SAVE_STAGES) { output.delete(); } return unpacked; }
/** * Unpack a stream in Pack200 format into a stream in JAR/ZIP format. * * @param input * stream in Pack200 format * @return stream in JAR/ZIP format * @throws IOException * in case of errors with the streams */ public static InputStream unpack(final InputStream input) throws IOException { final ByteArrayOutputStream buffer = new ByteArrayOutputStream(); final JarOutputStream jar = new JarOutputStream(buffer); Pack200.newUnpacker().unpack(new NoCloseInput(input), jar); jar.finish(); return new ByteArrayInputStream(buffer.toByteArray()); }
public static InputStream unwrapPack200(InputStream packed) throws IOException { BufferedInputStream buffered = new BufferedInputStream(packed); buffered.mark(4); byte[] magic = new byte[4]; buffered.read(magic, 0, 4); buffered.reset(); InputStream in = buffered; if (magic[0] == (byte) 0x1F && magic[1] == (byte) 0x8B && magic[2] == (byte) 0x08) { // this is a gziped pack200 in = new GZIPInputStream(in); } Unpacker unpacker = Pack200.newUnpacker(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); JarOutputStream jar = new JarOutputStream(baos); unpacker.unpack(new UncloseInputStream(in), jar); jar.close(); return new ByteArrayInputStream(baos.toByteArray()); }
/** * Unpacks a pack200 packed jar file from {@code packedJar} into {@code target}. If {@code * packedJar} has a {@code .gz} extension, it will be gunzipped first. */ public static void unpackPacked200Jar (File packedJar, File target) throws IOException { try (InputStream packJarIn = new FileInputStream(packedJar); JarOutputStream jarOut = new JarOutputStream(new FileOutputStream(target))) { boolean gz = (packedJar.getName().endsWith(".gz") || packedJar.getName().endsWith(".gz_new")); try (InputStream packJarIn2 = (gz ? new GZIPInputStream(packJarIn) : packJarIn)) { Pack200.Unpacker unpacker = Pack200.newUnpacker(); unpacker.unpack(packJarIn2, jarOut); } } }
protected void unpack(File packFile, File jarFile) throws IOException, FileNotFoundException { InputStream is = new GZIPInputStream(new BufferedInputStream(new FileInputStream(packFile))); try { JarOutputStream os = new JarOutputStream(new BufferedOutputStream(new FileOutputStream(jarFile))); try { Unpacker unpacker = Pack200.newUnpacker(); unpacker.unpack(is, os); } finally { close(os); } } finally { close(is); } }
private void unpack200(Path compressedFile, Path jarFile) { logger.debug("Unpacking plugin " + compressedFile); Pack200.Unpacker unpacker = Pack200.newUnpacker(); try { try (JarOutputStream jarStream = new JarOutputStream(new BufferedOutputStream(Files.newOutputStream(jarFile))); InputStream in = new GZIPInputStream(new BufferedInputStream(Files.newInputStream(compressedFile)))) { unpacker.unpack(in, jarStream); } } catch (IOException e) { throw new IllegalStateException(e); } }
private File unpack200(String pluginKey, File compressedFile) { LOGGER.debug("Unpacking plugin {}", pluginKey); File jar = newTempFile(); try (InputStream input = new GZIPInputStream(new BufferedInputStream(FileUtils.openInputStream(compressedFile))); JarOutputStream output = new JarOutputStream(new BufferedOutputStream(FileUtils.openOutputStream(jar)))) { Pack200.newUnpacker().unpack(input, output); } catch (IOException e) { throw new IllegalStateException(format("Fail to download plugin [%s]. Pack200 error.", pluginKey), e); } return jar; }
private Pack200CompressorInputStream(final InputStream in, final File f, final Pack200Strategy mode, final Map<String, String> props) throws IOException { originalInput = in; streamBridge = mode.newStreamBridge(); try (final JarOutputStream jarOut = new JarOutputStream(streamBridge)) { final Pack200.Unpacker u = Pack200.newUnpacker(); if (props != null) { u.properties().putAll(props); } if (f == null) { u.unpack(new FilterInputStream(in) { @Override public void close() { // unpack would close this stream but we // want to give the user code more control } }, jarOut); } else { u.unpack(f, jarOut); } } }