// Compresses files listed in "files" into a .zip file called "name"
public void compress(ArrayList<String> files, String zipName) throws Exception {
byte data[] = new byte[BUFFER];
// File buffer streams
BufferedInputStream origin = null;
String zipDir = zipName;
FileOutputStream zipDest = new FileOutputStream(zipDir);
ZipOutputStream zipOut = new ZipOutputStream(new BufferedOutputStream(zipDest));
// Set compression method
zipOut.setMethod(ZipOutputStream.DEFLATED);
// Iterate compressing contained files
for (int i = 0; i < files.size(); i++) {
String address = files.get(i);
FileInputStream fj = new FileInputStream(address);
origin = new BufferedInputStream(fj, BUFFER);
String[] splits = address.split("\\\\");
String name = splits[splits.length - 1];
ZipEntry entry = new ZipEntry(name);
zipOut.putNextEntry(entry);
int count;
while ((count = origin.read(data, 0, BUFFER)) != -1) {
zipOut.write(data, 0, count);
}
origin.close();
}
zipOut.close();
}
public String createBundle(String apiproxydir) throws IOException {
System.out.println("apiproxydir" + apiproxydir);
File dirObj = new File(apiproxydir);
ZipOutputStream out = new ZipOutputStream(new FileOutputStream("apiproxy" + ".zip"));
addDir(dirObj, out);
out.close();
return null;
}
public void installFramework(File frameFile, String tag) throws AndrolibException {
InputStream in = null;
ZipOutputStream out = null;
try {
ZipFile zip = new ZipFile(frameFile);
ZipEntry entry = zip.getEntry("resources.arsc");
if (entry == null) {
throw new AndrolibException("Can't find resources.arsc file");
}
in = zip.getInputStream(entry);
byte[] data = IOUtils.toByteArray(in);
ARSCData arsc = ARSCDecoder.decode(new ByteArrayInputStream(data), true, true);
publicizeResources(data, arsc.getFlagsOffsets());
File outFile =
new File(
getFrameworkDir(),
String.valueOf(arsc.getOnePackage().getId())
+ (tag == null ? "" : '-' + tag)
+ ".apk");
out = new ZipOutputStream(new FileOutputStream(outFile));
out.setMethod(ZipOutputStream.STORED);
CRC32 crc = new CRC32();
crc.update(data);
entry = new ZipEntry("resources.arsc");
entry.setSize(data.length);
entry.setCrc(crc.getValue());
out.putNextEntry(entry);
out.write(data);
LOGGER.info("Framework installed to: " + outFile);
} catch (ZipException ex) {
throw new AndrolibException(ex);
} catch (IOException ex) {
throw new AndrolibException(ex);
} finally {
if (in != null) {
try {
in.close();
} catch (IOException ex) {
}
}
if (out != null) {
try {
out.close();
} catch (IOException ex) {
}
}
}
}
private void addIndex(JarIndex index, ZipOutputStream zos) throws IOException {
ZipEntry e = new ZipEntry(INDEX_NAME);
e.setTime(System.currentTimeMillis());
if (flag0) {
CRC32OutputStream os = new CRC32OutputStream();
index.write(os);
os.updateEntry(e);
}
zos.putNextEntry(e);
index.write(zos);
zos.closeEntry();
}
// TODO da ohnehin ein Zip Ordner besteht könnte man hier auch alle weiteren Informationen ablegen
// material, animation usw.
@Override
public void writeModel(OutputStream out, Model[] models) throws IOException {
ZipOutputStream zip = new ZipOutputStream(out);
for (int i = 0; i < models.length; i++) {
zip.putNextEntry(new ZipEntry("model" + i + ".ctm"));
writeSingleModel(zip, models[i]);
zip.closeEntry();
}
zip.finish();
}
/** Adds a new file entry to the ZIP output stream. */
void addFile(ZipOutputStream zos, File file) throws IOException {
String name = file.getPath();
boolean isDir = file.isDirectory();
if (isDir) {
name = name.endsWith(File.separator) ? name : (name + File.separator);
}
name = entryName(name);
if (name.equals("") || name.equals(".") || name.equals(zname)) {
return;
} else if ((name.equals(MANIFEST_DIR) || name.equals(MANIFEST_NAME)) && !Mflag) {
if (vflag) {
output(formatMsg("out.ignore.entry", name));
}
return;
}
long size = isDir ? 0 : file.length();
if (vflag) {
out.print(formatMsg("out.adding", name));
}
ZipEntry e = new ZipEntry(name);
e.setTime(file.lastModified());
if (size == 0) {
e.setMethod(ZipEntry.STORED);
e.setSize(0);
e.setCrc(0);
} else if (flag0) {
crc32File(e, file);
}
zos.putNextEntry(e);
if (!isDir) {
copy(file, zos);
}
zos.closeEntry();
/* report how much compression occurred. */
if (vflag) {
size = e.getSize();
long csize = e.getCompressedSize();
out.print(formatMsg2("out.size", String.valueOf(size), String.valueOf(csize)));
if (e.getMethod() == ZipEntry.DEFLATED) {
long ratio = 0;
if (size != 0) {
ratio = ((size - csize) * 100) / size;
}
output(formatMsg("out.deflated", String.valueOf(ratio)));
} else {
output(getMsg("out.stored"));
}
}
}
private void storeFile(File file) throws FileNotFoundException, IOException {
Console.printStatus("Storing: " + file);
try (FileInputStream inputStream = new FileInputStream(file)) {
_zipStream.putNextEntry(new ZipEntry(file.getCanonicalPath()));
// Copy the content to the zip stream:
int length;
while ((length = inputStream.read(buffer)) > 0) _zipStream.write(buffer, 0, length);
_zipStream.closeEntry();
}
}
@Override
public void close() throws ArchiveException {
try {
output.close();
} catch (final IOException e) {
throw new ArchiveException("Could not close archive.", e);
}
}
/**
* Loop through the ZIP file, copying its entries into a new, temporary ZIP file, skipping the
* entry to be deleted. Then replace the original file with the new one.
*/
protected Integer deleteEntry() throws XMLDataStoreException {
try {
ZipInputStream inStream = this.buildZipInputStream();
File outFile = this.buildTempFile();
ZipOutputStream outStream = new ZipOutputStream(new FileOutputStream(outFile));
byte[] buffer = new byte[32768];
int inCount = 0;
int outCount = 0;
// copy all the entries except the one to be deleted
ZipEntry entry = inStream.getNextEntry();
while (entry != null) {
inCount++;
if (!this.getZipEntryName().equals(entry.getName())) {
outCount++;
outStream.putNextEntry(entry);
int byteCount;
while ((byteCount = inStream.read(buffer)) != -1) {
outStream.write(buffer, 0, byteCount);
}
outStream.closeEntry();
}
entry = inStream.getNextEntry();
}
inStream.close();
if (outCount == 0) {
// add a dummy record to an empty file so we can close it
// this is required by ZipOutputStream
outStream.putNextEntry(new ZipEntry("delete.txt"));
outStream.write(
"This file is a place-holder. The containing ZIP file should be deleted.".getBytes());
outStream.closeEntry();
}
outStream.close();
if (outCount == inCount) {
// no entries were removed - just delete the temp file
outFile.delete();
} else {
// at least one entry removed - delete the original file
this.getFile().delete();
if (outCount == 0) {
// NO entries remain - just delete the temp file too
outFile.delete();
} else {
// entries remain - replace original file with temp file
outFile.renameTo(this.getFile());
}
}
return new Integer(inCount - outCount); // should be 0 or 1
} catch (IOException ex) {
throw XMLDataStoreException.ioException(ex);
}
}
public void addToZipFile(String fileName, ZipOutputStream zos)
throws FileNotFoundException, IOException {
System.out.println("Writing '" + fileName + "' to zip file");
File file = new File(fileName);
FileInputStream fis = new FileInputStream(file);
zos.putNextEntry(new ZipEntry(new File(fileName).getName()));
byte[] bytes = new byte[1024];
int length;
while ((length = fis.read(bytes)) >= 0) {
zos.write(bytes, 0, length);
}
zos.closeEntry();
fis.close();
}
/**
* Zips byte array.
*
* @param input Input bytes.
* @param initBufSize Initial buffer size.
* @return Zipped byte array.
* @throws IOException If failed.
*/
public static byte[] zipBytes(byte[] input, int initBufSize) throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream(initBufSize);
try (ZipOutputStream zos = new ZipOutputStream(bos)) {
ZipEntry entry = new ZipEntry("");
try {
entry.setSize(input.length);
zos.putNextEntry(entry);
zos.write(input);
} finally {
zos.closeEntry();
}
}
return bos.toByteArray();
}
/**
* Puts the uninstaller.
*
* @exception Exception Description of the Exception
*/
private void putUninstaller() throws Exception {
// Me make the .uninstaller directory
String dest = translatePath("$INSTALL_PATH") + File.separator + "Uninstaller";
String jar = dest + File.separator + "uninstaller.jar";
File pathMaker = new File(dest);
pathMaker.mkdirs();
// We log the uninstaller deletion information
UninstallData udata = UninstallData.getInstance();
udata.setUninstallerJarFilename(jar);
udata.setUninstallerPath(dest);
// We open our final jar file
FileOutputStream out = new FileOutputStream(jar);
ZipOutputStream outJar = new ZipOutputStream(out);
idata.uninstallOutJar = outJar;
outJar.setLevel(9);
udata.addFile(jar);
// We copy the uninstaller
InputStream in = getClass().getResourceAsStream("/res/IzPack.uninstaller");
ZipInputStream inRes = new ZipInputStream(in);
ZipEntry zentry = inRes.getNextEntry();
while (zentry != null) {
// Puts a new entry
outJar.putNextEntry(new ZipEntry(zentry.getName()));
// Byte to byte copy
int unc = inRes.read();
while (unc != -1) {
outJar.write(unc);
unc = inRes.read();
}
// Next one please
inRes.closeEntry();
outJar.closeEntry();
zentry = inRes.getNextEntry();
}
inRes.close();
// We put the langpack
in = getClass().getResourceAsStream("/langpacks/" + idata.localeISO3 + ".xml");
outJar.putNextEntry(new ZipEntry("langpack.xml"));
int read = in.read();
while (read != -1) {
outJar.write(read);
read = in.read();
}
outJar.closeEntry();
}
/**
* zip压缩功能. 压缩baseDir(文件夹目录)下所有文件，包括子目录
*
* @throws Exception
*/
public static void zipFile(String baseDir, String fileName, String comment) throws Exception {
List fileList = getSubFiles(new File(baseDir));
ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(fileName));
ZipEntry ze = null;
byte[] buf = new byte[BUFFER];
int readLen = 0;
for (int i = 0; i < fileList.size(); i++) {
File f = (File) fileList.get(i);
ze = new ZipEntry(getAbsFileName(baseDir, f));
ze.setSize(f.length());
ze.setTime(f.lastModified());
zos.putNextEntry(ze);
InputStream is = new BufferedInputStream(new FileInputStream(f));
while ((readLen = is.read(buf, 0, BUFFER)) != -1) {
zos.write(buf, 0, readLen);
}
is.close();
}
zos.setComment(comment);
zos.close();
}
static void addDir(File dirObj, ZipOutputStream out) throws IOException {
File[] files = dirObj.listFiles();
byte[] tmpBuf = new byte[1024];
assert files != null;
for (File file : files) {
if (file.isDirectory()) {
addDir(file, out);
continue;
}
FileInputStream in = new FileInputStream(file.getPath());
System.out.println(" Adding: " + file.getPath());
out.putNextEntry(new ZipEntry(file.getPath()));
int len;
while ((len = in.read(tmpBuf)) > 0) {
out.write(tmpBuf, 0, len);
}
out.closeEntry();
in.close();
}
}
/** Creates a new JAR file. */
void create(OutputStream out, Manifest manifest) throws IOException {
ZipOutputStream zos = new JarOutputStream(out);
if (flag0) {
zos.setMethod(ZipOutputStream.STORED);
}
if (manifest != null) {
if (vflag) {
output(getMsg("out.added.manifest"));
}
ZipEntry e = new ZipEntry(MANIFEST_DIR);
e.setTime(System.currentTimeMillis());
e.setSize(0);
e.setCrc(0);
zos.putNextEntry(e);
e = new ZipEntry(MANIFEST_NAME);
e.setTime(System.currentTimeMillis());
if (flag0) {
crc32Manifest(e, manifest);
}
zos.putNextEntry(e);
manifest.write(zos);
zos.closeEntry();
}
for (File file : entries) {
addFile(zos, file);
}
zos.close();
}
public static String CreateZip(String[] filesToZip, String zipFileName) {
byte[] buffer = new byte[18024];
try {
ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipFileName));
out.setLevel(Deflater.BEST_COMPRESSION);
for (int i = 0; i < filesToZip.length; i++) {
FileInputStream in = new FileInputStream(filesToZip[i]);
String fileName = null;
for (int X = filesToZip[i].length() - 1; X >= 0; X--) {
if (filesToZip[i].charAt(X) == '\\' || filesToZip[i].charAt(X) == '/') {
fileName = filesToZip[i].substring(X + 1);
break;
} else if (X == 0) fileName = filesToZip[i];
}
out.putNextEntry(new ZipEntry(fileName));
int len;
while ((len = in.read(buffer)) > 0) out.write(buffer, 0, len);
out.closeEntry();
in.close();
}
out.close();
} catch (IllegalArgumentException e) {
return "Failed to create zip: " + e.toString();
} catch (FileNotFoundException e) {
return "Failed to create zip: " + e.toString();
} catch (IOException e) {
return "Failed to create zip: " + e.toString();
}
return "Success";
}
public static boolean comprimirEnZip(
String[] nombresAComprimir, String nombreComprimido, String rootPath) {
// Ficheros a incluir en el archivo ZIP
String[] filenames = nombresAComprimir;
// Buffer para ir leyendo los ficheros a comprimir
byte[] buf = new byte[1024];
try {
// El fichero ZIP resultante
String outFilename = nombreComprimido;
ZipOutputStream out = new ZipOutputStream(new FileOutputStream(rootPath + outFilename));
// Comprimimos los ficheros
for (int i = 0; i < filenames.length; i++) {
FileInputStream in = new FileInputStream(rootPath + filenames[i]);
// Añadimos el fichero al ZIP
out.putNextEntry(new ZipEntry(rootPath + filenames[i]));
// Empezamos a transferir el contenido del fichero al ZIP
int len;
while ((len = in.read(buf)) > 0) {
out.write(buf, 0, len);
}
// Completamos esa entrada del ZIP, para empezar una nueva, si hubiese mas ficheros
out.closeEntry();
in.close();
}
// Cerramos el fichero comprimido, todo listo
out.close();
return true;
} catch (IOException e) {
return false;
}
}
public static void main(String[] args) throws Exception {
Reader trainingFile = null;
// Process arguments
int restArgs = commandOptions.processOptions(args);
// Check arguments
if (restArgs != args.length) {
commandOptions.printUsage(true);
throw new IllegalArgumentException("Unexpected arg " + args[restArgs]);
}
if (trainFileOption.value == null) {
commandOptions.printUsage(true);
throw new IllegalArgumentException("Expected --train-file FILE");
}
if (modelFileOption.value == null) {
commandOptions.printUsage(true);
throw new IllegalArgumentException("Expected --model-file FILE");
}
// Get the CRF structure specification.
ZipFile zipFile = new ZipFile(modelFileOption.value);
ZipEntry zipEntry = zipFile.getEntry("crf-info.xml");
CRFInfo crfInfo = new CRFInfo(zipFile.getInputStream(zipEntry));
StringBuffer crfInfoBuffer = new StringBuffer();
BufferedReader reader =
new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry)));
String line;
while ((line = reader.readLine()) != null) {
crfInfoBuffer.append(line).append('\n');
}
reader.close();
// Create the CRF, and train it.
CRF4 crf = createCRF(trainFileOption.value, crfInfo);
// Create a new zip file for our output. This will overwrite
// the file we used for input.
ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(modelFileOption.value));
// Copy the CRF info xml to the output zip file.
zos.putNextEntry(new ZipEntry("crf-info.xml"));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(zos));
writer.write(crfInfoBuffer.toString());
writer.flush();
zos.closeEntry();
// Save the CRF classifier model to the output zip file.
zos.putNextEntry(new ZipEntry("crf-model.ser"));
ObjectOutputStream oos = new ObjectOutputStream(zos);
oos.writeObject(crf);
oos.flush();
zos.closeEntry();
zos.close();
}
/**
* Rename the ZIP file to a temporary file, then copy its entries back into the original ZIP file,
* leaving the stream open and returning it.
*/
protected Writer buildWriteStream(boolean entryShouldExist) throws XMLDataStoreException {
try {
File inFile = this.buildTempFile();
inFile.delete(); // the file actually gets created - delete it
boolean renameSucceeded = this.getFile().renameTo(inFile);
ZipInputStream inStream = this.buildZipInputStream(inFile);
ZipOutputStream outStream = this.buildZipOutputStream();
boolean entryActuallyExists = false;
byte[] buffer = new byte[32768];
ZipEntry entry = inStream.getNextEntry();
while (entry != null) {
boolean weWantToWriteTheEntry = true;
if (this.getZipEntryName().equals(entry.getName())) {
entryActuallyExists = true;
// if we were expecting the entry, skip it;
// if we were NOT expecting the entry, allow it to be rewritten
// so the file is restored to its original condition
if (entryShouldExist) {
weWantToWriteTheEntry = false;
}
}
if (weWantToWriteTheEntry) {
outStream.putNextEntry(entry);
int byteCount;
while ((byteCount = inStream.read(buffer)) != -1) {
outStream.write(buffer, 0, byteCount);
}
outStream.closeEntry();
}
entry = inStream.getNextEntry();
}
// close and delete the temporary file
inStream.close();
inFile.delete();
// check for invalid state
if (entryShouldExist != entryActuallyExists) {
outStream.close(); // close it since we will not be returning it
// need more helpful exceptions here
if (entryActuallyExists) {
throw XMLDataStoreException.fileAlreadyExists(new File(this.getZipEntryName()));
} else {
throw XMLDataStoreException.fileNotFound(new File(this.getZipEntryName()), null);
}
}
outStream.putNextEntry(new ZipEntry(this.getZipEntryName()));
return new OutputStreamWriter(outStream);
} catch (IOException ex) {
throw XMLDataStoreException.ioException(ex);
}
}
private boolean updateManifest(Manifest m, ZipOutputStream zos) throws IOException {
addVersion(m);
addCreatedBy(m);
if (ename != null) {
addMainClass(m, ename);
}
if (pname != null) {
if (!addProfileName(m, pname)) {
return false;
}
}
ZipEntry e = new ZipEntry(MANIFEST_NAME);
e.setTime(System.currentTimeMillis());
if (flag0) {
crc32Manifest(e, m);
}
zos.putNextEntry(e);
m.write(zos);
if (vflag) {
output(getMsg("out.update.manifest"));
}
return true;
}
public static void main(String[] args) throws IOException {
int servPort = Integer.parseInt(args[0]);
String ksName = "keystore.jks";
char ksPass[] = "password".toCharArray();
char ctPass[] = "password".toCharArray();
try {
KeyStore ks = KeyStore.getInstance("JKS");
ks.load(new FileInputStream(ksName), ksPass);
KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
kmf.init(ks, ctPass);
SSLContext sc = SSLContext.getInstance("SSL");
sc.init(kmf.getKeyManagers(), null, null);
SSLServerSocketFactory ssf = sc.getServerSocketFactory();
SSLServerSocket s = (SSLServerSocket) ssf.createServerSocket(servPort);
while (true) {
// Listen for a TCP connection request.
SSLSocket c = (SSLSocket) s.accept();
BufferedOutputStream out = new BufferedOutputStream(c.getOutputStream(), 1024);
BufferedInputStream in = new BufferedInputStream(c.getInputStream(), 1024);
byte[] byteBuffer = new byte[1024];
int count = 0;
while ((byteBuffer[count] = (byte) in.read()) != -2) {
count++;
}
String newFile = new String(byteBuffer, 0, count, "US-ASCII");
FileOutputStream writer = new FileOutputStream(newFile.trim());
int buffSize = 0;
while ((buffSize = in.read(byteBuffer, 0, 1024)) != -1) {
int index = 0;
if ((index =
(new String(byteBuffer, 0, buffSize, "US-ASCII"))
.indexOf("------MagicStringCSE283Miami"))
== -1) {
writer.write(byteBuffer, 0, buffSize);
} else {
writer.write(byteBuffer, 0, index);
break;
}
}
writer.flush();
writer.close();
ZipOutputStream outZip = new ZipOutputStream(new BufferedOutputStream(out));
FileInputStream fin = new FileInputStream(newFile.trim());
BufferedInputStream origin = new BufferedInputStream(fin, 1024);
ZipEntry entry = new ZipEntry(newFile.trim());
outZip.putNextEntry(entry);
byteBuffer = new byte[1024];
int bytes = 0;
while ((bytes = origin.read(byteBuffer, 0, 1024)) != -1) {
outZip.write(byteBuffer, 0, bytes);
}
origin.close();
outZip.flush();
outZip.close();
out.flush();
out.close();
}
} catch (Exception e) {
System.err.println(e.toString());
}
}
/** Updates an existing jar file. */
boolean update(InputStream in, OutputStream out, InputStream newManifest, JarIndex jarIndex)
throws IOException {
ZipInputStream zis = new ZipInputStream(in);
ZipOutputStream zos = new JarOutputStream(out);
ZipEntry e = null;
boolean foundManifest = false;
boolean updateOk = true;
if (jarIndex != null) {
addIndex(jarIndex, zos);
}
// put the old entries first, replace if necessary
while ((e = zis.getNextEntry()) != null) {
String name = e.getName();
boolean isManifestEntry = equalsIgnoreCase(name, MANIFEST_NAME);
if ((jarIndex != null && equalsIgnoreCase(name, INDEX_NAME)) || (Mflag && isManifestEntry)) {
continue;
} else if (isManifestEntry && ((newManifest != null) || (ename != null) || (pname != null))) {
foundManifest = true;
if (newManifest != null) {
// Don't read from the newManifest InputStream, as we
// might need it below, and we can't re-read the same data
// twice.
FileInputStream fis = new FileInputStream(mname);
boolean ambiguous = isAmbiguousMainClass(new Manifest(fis));
fis.close();
if (ambiguous) {
return false;
}
}
// Update the manifest.
Manifest old = new Manifest(zis);
if (newManifest != null) {
old.read(newManifest);
}
if (!updateManifest(old, zos)) {
return false;
}
} else {
if (!entryMap.containsKey(name)) { // copy the old stuff
// do our own compression
ZipEntry e2 = new ZipEntry(name);
e2.setMethod(e.getMethod());
e2.setTime(e.getTime());
e2.setComment(e.getComment());
e2.setExtra(e.getExtra());
if (e.getMethod() == ZipEntry.STORED) {
e2.setSize(e.getSize());
e2.setCrc(e.getCrc());
}
zos.putNextEntry(e2);
copy(zis, zos);
} else { // replace with the new files
File f = entryMap.get(name);
addFile(zos, f);
entryMap.remove(name);
entries.remove(f);
}
}
}
// add the remaining new files
for (File f : entries) {
addFile(zos, f);
}
if (!foundManifest) {
if (newManifest != null) {
Manifest m = new Manifest(newManifest);
updateOk = !isAmbiguousMainClass(m);
if (updateOk) {
if (!updateManifest(m, zos)) {
updateOk = false;
}
}
} else if (ename != null || pname != null) {
if (!updateManifest(new Manifest(), zos)) {
updateOk = false;
}
}
}
zis.close();
zos.close();
return updateOk;
}
private void writeEntry(final String name, final FileContent content) throws IOException {
output.putNextEntry(entryFor(name, content));
writeToEntry(content);
output.closeEntry();
}
public byte[] ZipIt(ArrayList<ResultType> items, String[] algorithm, String[] filetype)
throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ZipOutputStream zos = new ZipOutputStream(baos);
BufferedInputStream bis;
String[] files = new String[10000];
File file;
int bytesRead;
byte[] buffer = new byte[1024];
int j = 0;
boolean flag;
for (int i = 0; i < items.size(); i++) {
ResultType g = (ResultType) items.get(i);
String folder = g.get("genomeNames");
file = new File("/storage/brcdownloads/patric2/genomes/" + folder);
if (!file.exists()) {
System.err.println("Skipping Folder: " + "/storage/brcdownloads/patric2/genomes/" + folder);
continue;
} else {
for (int k = 0; k < algorithm.length; k++) {
for (int m = 0; m < filetype.length; m++) {
flag = false;
file =
new File(
"/storage/brcdownloads/patric2/genomes/"
+ folder
+ "/"
+ folder
+ (filetype[m].equals(".fna") ? "" : algorithm[k])
+ filetype[m]);
if (!file.exists()) {
System.err.println("Skipping File: " + file.getAbsolutePath());
} else {
// System.out.println("File: " + file.getAbsolutePath());
for (int z = 0; z < files.length; z++) {
if (files[z] != null && files[z].equals(file.getAbsolutePath())) {
flag = true;
break;
}
}
// System.out.println(flag);
if (!flag) {
files[j] = file.getAbsolutePath();
j++;
}
}
}
}
}
}
// System.out.println(j);
if (j > 0) {
for (int i = 0; i < j; i++) {
file = new File(files[i]);
bis = new BufferedInputStream(new FileInputStream(file));
ZipEntry entry = new ZipEntry(file.getName());
zos.putNextEntry(entry);
while ((bytesRead = bis.read(buffer)) != -1) {
zos.write(buffer, 0, bytesRead);
}
bis.close();
zos.closeEntry();
}
zos.close();
}
return baos.toByteArray();
}
@Override
public void close() throws IOException {
_zipStream.close();
Console.printStatus("Closed: " + _fileName);
}