public static void unzipIntoDirectory(InputStream inputStream, File directory) {
if (directory.isFile()) return;
directory.mkdirs();
try {
inputStream = new BufferedInputStream(inputStream);
inputStream = new ZipInputStream(inputStream);
for (ZipEntry entry = null;
(entry = ((ZipInputStream) inputStream).getNextEntry()) != null; ) {
StringBuilder pathBuilder =
new StringBuilder(directory.getPath()).append('/').append(entry.getName());
File file = new File(pathBuilder.toString());
if (entry.isDirectory()) {
file.mkdirs();
continue;
}
StreamUtil.write(pathBuilder, inputStream, false);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
StreamUtil.closeQuietly(inputStream);
}
}
/** Adds byte content into the zip as a file. */
public static void addToZip(ZipOutputStream zos, byte[] content, String path, String comment)
throws IOException {
while (path.length() != 0 && path.charAt(0) == '/') {
path = path.substring(1);
}
if (StringUtil.endsWithChar(path, '/')) {
path = path.substring(0, path.length() - 1);
}
ZipEntry zipEntry = new ZipEntry(path);
zipEntry.setTime(System.currentTimeMillis());
if (comment != null) {
zipEntry.setComment(comment);
}
zos.putNextEntry(zipEntry);
InputStream is = new ByteArrayInputStream(content);
try {
StreamUtil.copy(is, zos);
} finally {
StreamUtil.close(is);
}
zos.closeEntry();
}
@Test
public void testCopy() {
AsciiInputStream in = new AsciiInputStream("input");
StringOutputStream out = new StringOutputStream();
try {
StreamUtil.copy(in, out);
} catch (IOException ioex) {
fail("StreamUtil.copy " + ioex.toString());
}
assertEquals("input", out.toString());
StreamUtil.close(out);
StreamUtil.close(in);
}
int encodedLength() throws IOException {
if (encoded != null) {
return 1 + StreamUtil.calculateBodyLength(encoded.length) + encoded.length;
} else {
return super.toDLObject().encodedLength();
}
}
static {
final Enumeration<URL> resources;
String jarName = "(unknown)";
String versionString = "(unknown)";
try {
final ClassLoader classLoader = Main.class.getClassLoader();
resources =
classLoader == null
? ModuleClassLoader.getSystemResources("META-INF/MANIFEST.MF")
: classLoader.getResources("META-INF/MANIFEST.MF");
while (resources.hasMoreElements()) {
final URL url = resources.nextElement();
try {
final InputStream stream = url.openStream();
if (stream != null)
try {
final Manifest manifest = new Manifest(stream);
final Attributes mainAttributes = manifest.getMainAttributes();
if (mainAttributes != null
&& "JBoss Modules".equals(mainAttributes.getValue("Specification-Title"))) {
jarName = mainAttributes.getValue("Jar-Name");
versionString = mainAttributes.getValue("Jar-Version");
}
} finally {
StreamUtil.safeClose(stream);
}
} catch (IOException ignored) {
}
}
} catch (IOException ignored) {
}
JAR_NAME = jarName;
VERSION_STRING = versionString;
}
public String httpGet(String urlStr) {
URL url = null;
HttpURLConnection conn = null;
Message msg = handler.obtainMessage();
;
try {
url = new URL(urlStr);
conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setConnectTimeout(5000);
conn.setReadTimeout(5000);
conn.connect();
if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
String result = StreamUtil.getStringFromInputStream(conn.getInputStream());
return result;
} else if (conn.getResponseCode() == HttpURLConnection.HTTP_NOT_FOUND) {
msg.what = VictorApplication.CODE_URL_NOT_FOUND;
msg.arg1 = 11111;
handler.sendMessage(msg);
}
} catch (MalformedURLException e) {
msg.what = VictorApplication.CODE_URL_ERROR;
msg.arg1 = 11111;
handler.sendMessage(msg);
e.printStackTrace();
} catch (IOException e) {
msg.what = VictorApplication.CODE_NET_ERROR;
msg.arg1 = 11111;
handler.sendMessage(msg);
e.printStackTrace();
}
return null;
}
/** Decompress gzip archive. */
public static File ungzip(File file) throws IOException {
String outFileName = FileNameUtil.removeExtension(file.getAbsolutePath());
File out = new File(outFileName);
out.createNewFile();
FileOutputStream fos = new FileOutputStream(out);
GZIPInputStream gzis = new GZIPInputStream(new FileInputStream(file));
try {
StreamUtil.copy(gzis, fos);
} finally {
StreamUtil.close(fos);
StreamUtil.close(gzis);
}
return out;
}
/** Tests that writing a String to an {@link OutputStream} works as expected. */
@Test
public void write() throws IOException {
ByteArrayOutputStream output = new ByteArrayOutputStream();
StreamUtil.writeString(output, "hello");
String written = new String(output.toByteArray(), StandardCharsets.US_ASCII);
assertEquals("hello\0", written);
}
/**
* Extracts zip file to the target directory. If patterns are provided only matched paths are
* extracted.
*
* @param zipFile zip file
* @param destDir destination directory
* @param patterns optional wildcard patterns of files to extract, may be <code>null</code>
*/
public static void unzip(File zipFile, File destDir, String... patterns) throws IOException {
ZipFile zip = new ZipFile(zipFile);
Enumeration zipEntries = zip.entries();
while (zipEntries.hasMoreElements()) {
ZipEntry entry = (ZipEntry) zipEntries.nextElement();
String entryName = entry.getName();
if (patterns != null && patterns.length > 0) {
if (Wildcard.matchPathOne(entryName, patterns) == -1) {
continue;
}
}
File file = (destDir != null) ? new File(destDir, entryName) : new File(entryName);
if (entry.isDirectory()) {
if (!file.mkdirs()) {
if (file.isDirectory() == false) {
throw new IOException("Failed to create directory: " + file);
}
}
} else {
File parent = file.getParentFile();
if (parent != null && !parent.exists()) {
if (!parent.mkdirs()) {
if (file.isDirectory() == false) {
throw new IOException("Failed to create directory: " + parent);
}
}
}
InputStream in = zip.getInputStream(entry);
OutputStream out = null;
try {
out = new FileOutputStream(file);
StreamUtil.copy(in, out);
} finally {
StreamUtil.close(out);
StreamUtil.close(in);
}
}
}
close(zip);
}
/** Compresses a file into gzip archive. */
public static File gzip(File file) throws IOException {
if (file.isDirectory() == true) {
throw new IOException("Can't gzip folder");
}
FileInputStream fis = new FileInputStream(file);
String gzipName = file.getAbsolutePath() + GZIP_EXT;
GZIPOutputStream gzos = new GZIPOutputStream(new FileOutputStream(gzipName));
try {
StreamUtil.copy(fis, gzos);
} finally {
StreamUtil.close(gzos);
StreamUtil.close(fis);
}
return new File(gzipName);
}
private String getUrlContent(CachedUrl url) throws IOException {
InputStream content = url.getUnfilteredInputStream();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
StreamUtil.copy(content, baos);
content.close();
String contentStr = new String(baos.toByteArray());
baos.close();
return contentStr;
}
int encodedLength() throws IOException {
if (!empty) {
ASN1Primitive primitive = obj.toASN1Primitive().toDERObject();
int length = primitive.encodedLength();
if (explicit) {
return StreamUtil.calculateTagLength(tagNo)
+ StreamUtil.calculateBodyLength(length)
+ length;
} else {
// header length already in calculation
length = length - 1;
return StreamUtil.calculateTagLength(tagNo) + length;
}
} else {
return StreamUtil.calculateTagLength(tagNo) + 1;
}
}
@Test
public void testCompare() {
try {
File file = new File(dataRoot, "file/a.txt");
FileInputStream in1 = new FileInputStream(file);
String content = "test file\r\n";
if (file.length() == 10) {
content = StringUtil.remove(content, '\r');
}
AsciiInputStream in2 = new AsciiInputStream(content);
assertTrue(StreamUtil.compare(in1, in2));
StreamUtil.close(in2);
StreamUtil.close(in1);
} catch (FileNotFoundException e) {
fail("StreamUtil.testCloneCompare " + e.toString());
} catch (IOException e) {
fail("StreamUtil.testCloneCompare " + e.toString());
}
}
public static void copyFile(File from, File into) {
if (!from.exists()) return;
if (from.getPath().equals(into.getPath())) return;
from.setReadable(true);
if (into.exists()) into.delete();
try {
StreamUtil.writeBuffer(into, new FileInputStream(from), true);
} catch (IOException e) {
e.printStackTrace();
}
}
/** Verify that using a ByteArrayInputStream does not allocate a new byte array. */
@Test
public void testByteArrayInputStream() throws Exception {
byte[] bytes = new byte[8];
InputStream input = new ByteArrayInputStream(bytes);
try {
byte[] bytesRead = StreamUtil.getBytesFromStream(input);
assertTrue(Arrays.equals(bytes, bytesRead));
} finally {
Closeables.close(input, true);
}
}
/** Compresses a file into zlib archive. */
public static File zlib(File file) throws IOException {
if (file.isDirectory() == true) {
throw new IOException("Can't zlib folder");
}
FileInputStream fis = new FileInputStream(file);
Deflater deflater = new Deflater(Deflater.BEST_COMPRESSION);
String zlibFileName = file.getAbsolutePath() + ZLIB_EXT;
DeflaterOutputStream dos =
new DeflaterOutputStream(new FileOutputStream(zlibFileName), deflater);
try {
StreamUtil.copy(fis, dos);
} finally {
StreamUtil.close(dos);
StreamUtil.close(fis);
}
return new File(zlibFileName);
}
/** Verify that using an offset with ByteArrayInputStream still produces correct output. */
@Test
public void testByteArrayInputStreamWithOffset() throws Exception {
byte[] bytes = new byte[] {0, 1, 2, 3, 4};
InputStream input = new ByteArrayInputStream(bytes, 1, 4);
try {
byte[] bytesRead = StreamUtil.getBytesFromStream(input);
byte[] expectedBytes = new byte[] {1, 2, 3, 4};
assertTrue(Arrays.equals(expectedBytes, bytesRead));
} finally {
Closeables.close(input, true);
}
}
@Test
public void testSuccessfulSkip() throws Exception {
InputStream inputStream = mock(InputStream.class);
when(inputStream.skip(anyLong())).thenReturn(2L);
assertEquals(10, StreamUtil.skip(inputStream, 10));
InOrder order = inOrder(inputStream);
order.verify(inputStream).skip(10);
order.verify(inputStream).skip(8);
order.verify(inputStream).skip(6);
order.verify(inputStream).skip(4);
order.verify(inputStream).skip(2);
verifyNoMoreInteractions(inputStream);
}
@Test
public void testGetBytes() {
try {
FileInputStream in = new FileInputStream(new File(dataRoot, "file/a.txt"));
byte[] data = StreamUtil.readBytes(in);
StreamUtil.close(in);
String s = new String(data);
s = StringUtil.remove(s, '\r');
assertEquals("test file\n", s);
in = new FileInputStream(new File(dataRoot, "file/a.txt"));
String str = new String(StreamUtil.readChars(in));
StreamUtil.close(in);
str = StringUtil.remove(str, '\r');
assertEquals("test file\n", str);
} catch (FileNotFoundException e) {
fail("StreamUtil.testGetBytes " + e.toString());
} catch (IOException e) {
fail("StreamUtil.testGetBytes " + e.toString());
}
}
@Test
public void testUnsuccessfulSkip() throws Exception {
InputStream inputStream = mock(InputStream.class);
when(inputStream.skip(anyLong())).thenReturn(3L, 5L, 0L, 6L, 0L);
when(inputStream.read()).thenReturn(3, -1);
assertEquals(15, StreamUtil.skip(inputStream, 20));
InOrder order = inOrder(inputStream);
order.verify(inputStream).skip(20);
order.verify(inputStream).skip(17);
order.verify(inputStream).skip(12);
order.verify(inputStream).read();
order.verify(inputStream).skip(11);
order.verify(inputStream).skip(5);
order.verify(inputStream).read();
verifyNoMoreInteractions(inputStream);
}
public static String getChecksum(Path filePath) throws IOException {
if (!isValidChecksum(filePath)) {
return "";
}
InputStream fileInputStream = null;
try {
fileInputStream = Files.newInputStream(filePath);
byte[] bytes = DigestUtils.sha1(fileInputStream);
return Base64.encodeBase64String(bytes);
} finally {
StreamUtil.cleanUp(fileInputStream);
}
}
public static byte[] readFile(String file) throws JDependException {
FileInputStream fis = null;
try {
fis = new FileInputStream(file);
return StreamUtil.getData(fis);
} catch (FileNotFoundException e) {
e.printStackTrace();
throw new JDependException(e);
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private static LayersConfig getLayersConfig(File repoRoot) {
File layersList = new File(repoRoot, "layers.conf");
if (!layersList.exists()) {
return new LayersConfig();
}
Reader reader = null;
try {
reader = new InputStreamReader(new FileInputStream(layersList), "UTF-8");
Properties props = new Properties();
props.load(reader);
return new LayersConfig(props);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
StreamUtil.safeClose(reader);
}
}
public static String getChecksum(Path filePath) throws IOException {
if (!Files.exists(filePath)
|| (Files.size(filePath) > PropsValues.SYNC_FILE_CHECKSUM_THRESHOLD_SIZE)) {
return "";
}
InputStream fileInputStream = null;
try {
fileInputStream = Files.newInputStream(filePath);
byte[] bytes = DigestUtils.sha1(fileInputStream);
return Base64.encodeBase64String(bytes);
} finally {
StreamUtil.cleanUp(fileInputStream);
}
}
public void testDiskRepairMessage() throws Exception {
int len = 100 * 1024;
byte[] repairData = ByteArray.makeRandomBytes(len);
V3LcapMessage src = makeRepairMessage(repairData);
assertEquals(len, src.getRepairDataLength());
assertEquals(V3LcapMessage.EST_ENCODED_HEADER_LENGTH + len, src.getEstimatedEncodedLength());
InputStream srcStream = src.getInputStream();
V3LcapMessage copy = new V3LcapMessage(srcStream, tempDir, theDaemon);
assertEqualMessages(src, copy);
assertEquals(len, copy.getRepairDataLength());
assertEquals(V3LcapMessage.EST_ENCODED_HEADER_LENGTH + len, src.getEstimatedEncodedLength());
InputStream in = copy.getRepairDataInputStream();
assertTrue(in + "", in instanceof FileInputStream);
ByteArrayOutputStream out = new ByteArrayOutputStream();
StreamUtil.copy(in, out);
byte[] repairCopy = out.toByteArray();
assertEquals(repairData, repairCopy);
// ensure that repeated delete doesn't cause error
copy.delete();
copy.delete();
}
public static byte[] getFileData(String fileName) throws JDependException {
assert fileName != null && fileName.length() != 0;
FileInputStream fis = null;
try {
fis = new FileInputStream(fileName);
return StreamUtil.getData(fis);
} catch (FileNotFoundException e) {
e.printStackTrace();
LogUtil.getInstance(FileUtil.class).systemError("文件[" + fileName + "]没有发现。");
throw new JDependException("文件[" + fileName + "]读取失败。", e);
} finally {
try {
if (fis != null) {
fis.close();
}
} catch (IOException ignore) {
}
}
}
private static String getServiceName(ClassLoader classLoader, String className)
throws IOException {
final InputStream stream = classLoader.getResourceAsStream("META-INF/services/" + className);
if (stream == null) {
return null;
}
try {
final BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
String line;
while ((line = reader.readLine()) != null) {
final int i = line.indexOf('#');
if (i != -1) {
line = line.substring(0, i);
}
line = line.trim();
if (line.length() == 0) continue;
return line;
}
return null;
} finally {
StreamUtil.safeClose(stream);
}
}
private void checkFileInputStream(int size) throws IOException {
byte[] bytesToWrite = new byte[size];
for (int i = 0; i < size; i++) {
bytesToWrite[i] = (byte) i; // It's okay to truncate
}
File tmpFile = File.createTempFile("streamUtil", "test");
InputStream input = null;
OutputStream output = null;
try {
output = new FileOutputStream(tmpFile);
output.write(bytesToWrite);
output.close();
input = new FileInputStream(tmpFile);
byte[] bytesRead = StreamUtil.getBytesFromStream(input);
assertTrue(Arrays.equals(bytesToWrite, bytesRead));
} finally {
Closeables.close(input, true);
Closeables.close(output, false);
assertTrue(tmpFile.delete());
}
}
@Override
int encodedLength() {
return 1 + StreamUtil.calculateBodyLength(bytes.length) + bytes.length;
}
/** Downloads resource as String. */
public static String downloadString(String url) throws IOException {
InputStream inputStream = new URL(url).openStream();
return new String(StreamUtil.readChars(inputStream));
}
