Invalid File

Hey everyone! So I'm trying to get this backup system to work and it does, to some extent. It copies all the files and puts them into a zip folder, however if I click on the file, there's nothing in it (even though I know there is because it shows the file size next to it) and when I try to unzip it, windows gives me an error stating that the file is invalid. Any ideas why? Thanks

Code:java

public class Backup extends Thread{
 
    private static Backup instance;
 
    public static Backup getInstance(){
        return instance;
    }
 
    public static void newRef(){
        instance = new Backup();
    }
 
    public void backup() {
        new Thread() {
            public void run() {
                Backup.this.startBackup();
            }
        }.start();
    }
 
    public void zipDir(String dir2zip, ZipOutputStream zos){
        try{
          File zipDir = new File(dir2zip);
          String[] dirList = zipDir.list();
 
          byte[] readBuffer = new byte[2156];
          int bytesIn = 0;
 
          for (String file : dirList) {
 
              File f = new File(zipDir, file);
              if (f.isDirectory()) {
                  String filePath = f.getPath();
                  zipDir(filePath, zos);
              }else{
                FileInputStream fis = new FileInputStream(f);
                ZipEntry anEntry = new ZipEntry(f.getPath());
                zos.putNextEntry(anEntry);
 
                while ((bytesIn = fis.read(readBuffer)) != -1) {
                    zos.write(readBuffer, 0, bytesIn);
                }
 
                fis.close();
            }
 
          }
        }catch(Exception e){
 
        }}
 
    public void startBackup(){
        try {
            File root = new File(".");
 
            File bfolder = new File(root.getAbsolutePath() + "/backup/");
 
            if (!bfolder.exists())
                bfolder.mkdir();
 
            File backup = new File(bfolder.getAbsolutePath() + "/backup.zip");
 
            if (!backup.exists())
                backup.createNewFile();
 
            try{
                ZipOutputStream zs = new ZipOutputStream(new FileOutputStream(backup));
                System.out.println(MessageManager.getConsolePrefix() + "Zipping files...");
                zipDir(root.getAbsolutePath(), zs);
                zs.close();
                System.out.println(MessageManager.getConsolePrefix() +"Done!");           
            }catch (Exception e){}
 
        }catch(Exception e){
            e.printStackTrace();
        }
 
        DateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy");
        java.util.Date dateTime = new java.util.Date();
        String date = dateFormat.format(dateTime);
 
        List<World> worlds = Bukkit.getWorlds();
        Object[] theWorlds = worlds.toArray();
        String path = new File("").getAbsolutePath();
 
        for(int i=0; i<theWorlds.length; i++){
            World w = (World) theWorlds[i];
            try {
                w.save();
            } catch (Exception e1) {}
 
            String wNam = w.getName();
            File srcFolder = new File(path + File.separator + wNam);
            File destFolder = new File(Main.getInstance().getDataFolder().getAbsolutePath() + File.separator + "World Backups" + File.separator + date + File.separator + wNam);
            destFolder.mkdirs();
            if(srcFolder.exists()){
                try{
                    Copier.copyFolder(srcFolder,destFolder);
                }catch(IOException e){}
            }
        }
    }
}
class Copier{
    public static void copyFolder(File src, File dest) throws IOException{
        if(src.isDirectory()){
            if(!dest.exists())
                dest.mkdir();
 
            String files[] = src.list();
            for (String file : files) {
                File srcFile = new File(src, file);
                File destFile = new File(dest, file);
 
                copyFolder(srcFile,destFile);
            }
        }else{
            InputStream in = new FileInputStream(src);
            OutputStream out = new FileOutputStream(dest);
            byte[] buffer = new byte[1024];
            int length;
 
            while ((length = in.read(buffer)) > 0)
                out.write(buffer, 0, length);
            in.close();
            out.close();
        }
    }
}[/i]

 

I still can't figure it out. I even posted on stackoverflow, but their answers have left me even more confused

 

The Gaming Grunts
Can you send a link to the post on stackoverflow?

 

Download the Zip4j library from http://www.lingala.net/zip4j/download.php it's the first binary jar file. copy that into your eclipse project and add it to the build path. Then copy the code below and that should be enough to get you started. If anything is unclear or my code below doesn't work or something else goes wrong let me know.
ps. if you want a description of what the methods in zip4j do when you hover over them download the source for Zip4j. It's the last link on the page. copy it somewhere in your eclipse project and then expand "Referenced Libraries" -> right click on the zip4j jar -> properites -> Java Source Attachment -> External File. and then navigate to the source zip.

Code:java

import java.io.File;
 
import net.lingala.zip4j.core.ZipFile;
import net.lingala.zip4j.exception.ZipException;
import net.lingala.zip4j.model.ZipParameters;
import net.lingala.zip4j.util.Zip4jConstants;
 
public class Zip {
public static void main(String[] args) {
zip(new File("C:/games/Minecraft/MCWorld"));
//unzip(new File("C:/games/Minecraft/MCWorld.zip"));
}
 
public static void zip(File directoryContainingMCWorld) {
try {
String dest = null;
if (directoryContainingMCWorld.isDirectory()) {
dest = directoryContainingMCWorld.getAbsolutePath()+".zip";
}
 
// Initiate ZipFile object with the path/name of the zip file.
ZipFile zipFile = new ZipFile(dest);
 
// Initiate Zip Parameters which define various properties such
// as compression method, etc.
ZipParameters parameters = new ZipParameters();
 
// set compression method to store compression
parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE);
 
// Set the compression level
parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL);
 
// Add folder to the zip file
zipFile.addFolder(directoryContainingMCWorld, parameters);
 
 
} catch (Exception e) {
e.printStackTrace();
}
}
 
public static void unzip(File zippedMCWorld) {
unzip(zippedMCWorld, null);
}
 
public static void unzip(File zippedMCWorld, String password) {
try {
ZipFile zipFile = new ZipFile(zippedMCWorld);
if (!zipFile.isValidZipFile()) {
System.err.println("invalid archive");
}
if (zipFile.isEncrypted()) {
zipFile.setPassword(password);
}
String MCWorld = zippedMCWorld.getAbsolutePath();
String name = zippedMCWorld.getName();
String dest = MCWorld.substring(0, MCWorld.length()-name.length()-1);
zipFile.extractAll(dest);
} catch (ZipException e) {
e.printStackTrace();
}
}
}

 

ZekeMo
I'd rather not rely on a library

 

@The Gaming Grunts
Ok I finally rewrote my entire zip class using ONLY the standard libraries. Here is the code.

Code:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;
 
public class Zip {
    public static void main(String[] args) throws Exception {
        String base =  "C:\\prog\\java\\testing\\Zip4j\\";
        //
        // - you don't have to use full paths and it doesn't matter if you use a / or a \
        //
        // zip(base+"mc", base+"backup\\");
        // - or
        // zip(base+"mc", base+"backup\\mc.zip");
        // - are the same thing
        //
        // zip(base+"mc");
        // - for simplicity this will create the zip in the same directory
        //
        //
        //
        // unzip(base+"backup/mc.zip", base);
        // - unzips to the specified directory
        //
        // unzip(base+"backup/mc.zip");
        // - unzips to the same directory
        //
        // - The destination folder must exist or an exception will be thrown
        //
        //
    }
 
    public static void zip(String MCWorld) {
        String src = new File(MCWorld).getAbsolutePath();
        String dest = src+".zip";
        zip(src, dest);
    }
 
    public static void zip(String MCWorld, String dest) {
        String base = getParent(new File(MCWorld).getAbsoluteFile());
        String zipName = null;
        if (dest.endsWith("\\") || dest.endsWith("/")) {
            String name = new File(MCWorld).getName()+".zip";
            zipName =  dest+name;
        } else {
            zipName = dest;
        }
        byte[] buffer = new byte[8192];
        try{
            ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipName));
            File[] binaryFile = list(MCWorld);
            for (int i=0; i<binaryFile.length; i++) {
                if (binaryFile[i].isDirectory()) continue;
                String fullPath = binaryFile[i].getAbsolutePath();
                String relative = fullPath.substring(base.length(), fullPath.length());
                ZipEntry ze = new ZipEntry(relative);
                ze.setTime(binaryFile[i].lastModified());
                zos.putNextEntry(ze);
                FileInputStream in = new FileInputStream(fullPath);
 
                int read = 0;
                while ((read = in.read(buffer, 0, 8192)) > 0) {
                    zos.write(buffer, 0, read);
                }
 
                in.close();
                zos.closeEntry();
            }
            zos.close();
        }catch(IOException ex){
            ex.printStackTrace();
        }
    }
 
    public static void unzip(String MCWorldzip) {
        String src = new File(MCWorldzip).getAbsolutePath();
        String dest = getParent(new File(MCWorldzip));
        unzip(src, dest);
    }
 
    public static void unzip(String MCWorldzip, String dest) {
        dest = new File(dest).getAbsolutePath()+"\\";
        try {
            ZipFile zipFile = new ZipFile(MCWorldzip);
            Enumeration<? extends ZipEntry> list = zipFile.entries();
 
            while (list.hasMoreElements()) {
                ZipEntry tmp = list.nextElement();
                BufferedReader br = new BufferedReader(new InputStreamReader(zipFile.getInputStream(tmp)));
                String tree = getTree(dest+tmp.toString());
                if (!new File(tree).exists())
                    new File(tree).mkdirs();
                if (tmp.isDirectory()) continue;
 
                File outputFile = new File(dest+tmp.toString());
                BufferedWriter bw = new BufferedWriter(new FileWriter(outputFile));
 
                int read = 0;
                char[] buffer = new char[8192];
                while ((read = br.read(buffer, 0, 8192)) > 0) {
                    bw.write(buffer, 0, read);
                }
                br.close();
                bw.close();
                outputFile.setLastModified(tmp.getTime());
            }
        } catch (ZipException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static String getTree(String dir) {
        if (dir.endsWith("/") || dir.endsWith("\\")) return dir;
        int end = dir.length();
        for (int i=dir.length()-1; i>=0; i--) {
            if (dir.charAt(i) == '\\' || dir.charAt(i) == '/') {
                end = i+1;
                break;
            }
        }
        return dir.substring(0, end);
    }
 
    public static String getParent(File dir) {
        String name = dir.getName();
        String fullPath = dir.getAbsolutePath();
        return fullPath.substring(0, fullPath.length()-name.length());
    }
 
 
    public static File[] list(String dir) {
        ArrayList<File> y = new ArrayList<File>();
        listr(new File(dir), y);
        Collections.sort(y, new fileDepth());
        File[] x = new File[y.size()];
        y.toArray(x);
        return x;
    }
 
    private static File[] listr(File file, ArrayList<File> y) {
        File[] children = file.listFiles();
        for (int i=0; i<children.length; i++) {
            if (children[i].isDirectory()) {
                listr(children[i], y);
            }
            y.add(children[i]);
        }
        return null;
    }
 
    public static class fileDepth implements Comparator<File> {
        public int compare(File o1, File o2) {
            String tmp1 = o1.getAbsolutePath();
            String tmp2 = o2.getAbsolutePath();
            int fo1 = 0;
            int fo2 = 0;
            for (int i=0; i<tmp1.length(); i++) {
                if (tmp1.charAt(i) == File.separatorChar) fo1++;
            }
            for (int i=0; i<tmp2.length(); i++) {
                if (tmp2.charAt(i) == File.separatorChar) fo2++;
            }
            if (fo1 < fo2) {
                return 1;
            } else if (fo2 < fo1) {
                return -1;
            }
            return 0;
        }
    }
}