Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2010 {Prodevelop}   {Task}

 */

package org.gvsig.installer.lib.impl.utils;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.zip.ZipEntry;

import java.util.zip.ZipException;

import java.util.zip.ZipInputStream;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.installer.lib.api.PackageInfo;

import org.gvsig.installer.lib.api.execution.InstallPackageServiceException;

import org.gvsig.installer.lib.impl.DefaultPackageInfo;

import org.gvsig.installer.lib.impl.info.InstallerInfoFileReader;

import org.gvsig.installer.lib.spi.InstallerInfoFileException;

/**

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera Llodr&aacute;</a>

 */

public class Decompress {

    private static final int OPTION_DECOMPRESS = 1;

    private static final int OPTION_READ_INSTALLINFO = 2;

    private static final int OPTION_INSTALL = 3;

    private int option = 0;

    private int BUFFER = 2048;

    private static final Logger logger = LoggerFactory

        .getLogger(Decompress.class);

    private List<PackageInfo> readedIinstallerInfos = null;

    private File outputDirectory = null;

    private List<PackageInfo> selectedInstallerInfos = null;

    private Map<PackageInfo, String> zipEntriesMap = null;

    public Decompress() {

    }

    public void decompressPlugins(InputStream is, File outputDirectory)

        throws InstallPackageServiceException {

        option = OPTION_DECOMPRESS;

        this.outputDirectory = outputDirectory;

        decompressFolderOfPlugins(is);

    }

    public void readPackageSetInstallInfos(InputStream is,

        List<PackageInfo> installerInfos, Map<PackageInfo, String> zipEntriesMap)

        throws InstallPackageServiceException {

        option = OPTION_READ_INSTALLINFO;

        this.readedIinstallerInfos = installerInfos;

        this.zipEntriesMap = zipEntriesMap;

        decompressFolderOfPlugins(is);

    }

    public void readPackageInstallInfo(InputStream is,

        List<PackageInfo> installerInfos,

        Map<PackageInfo, String> zipEntriesMap, String name)

        throws InstallPackageServiceException {

        option = OPTION_READ_INSTALLINFO;

        this.readedIinstallerInfos = installerInfos;

        this.zipEntriesMap = zipEntriesMap;

        decompressFolderOfPluginFromPackage(is, name);

    }

    public void decompressPlugin(InputStream is, File outputDirectory)

        throws InstallPackageServiceException {

        try {

            option = OPTION_DECOMPRESS;

            this.outputDirectory = outputDirectory;

            decompressPlugin(new ZipInputStream(is));

        } catch (Exception e) {

            throw new InstallPackageServiceException(

                "Error reading the plugin", e);

        }

    }

    public InputStream searchPlugin(InputStream is, String zipEntry)

        throws InstallPackageServiceException {

        ZipEntry entry = null;

        try {

            ZipInputStream zipInputStream = new ZipInputStream(is);

            while ((entry = zipInputStream.getNextEntry()) != null) {

                if (entry.getName().equals(zipEntry)) {

                    return zipInputStream;

                }

                zipInputStream.closeEntry();

            }

            zipInputStream.closeEntry();

            zipInputStream.close();

        } catch (Exception e) {

            throw new InstallPackageServiceException(

                "Error reading the plugin", e);

        }

        return null;

    }

    public void installFromStream(InputStream is, PackageInfo installerInfo)

        throws InstallPackageServiceException {

        option = OPTION_INSTALL;

        this.selectedInstallerInfos = new ArrayList<PackageInfo>();

        this.selectedInstallerInfos.add(installerInfo);

        decompressFolderOfPlugins(is);

    }

    public void installFromStream(InputStream is,

        List<PackageInfo> installerInfos) throws InstallPackageServiceException {

        option = OPTION_INSTALL;

        this.selectedInstallerInfos = installerInfos;

        decompressFolderOfPlugins(is);

    }

    private void decompressFolderOfPlugins(InputStream is)

        throws InstallPackageServiceException {

        ZipInputStream zipInputStream = new ZipInputStream(is);

        ZipEntry entry = null;

        try {

            while ((entry = zipInputStream.getNextEntry()) != null) {

                logger.debug("Extracting all Plugins, plugin: " + entry);

                if (option == OPTION_INSTALL) {

                } else

                    if (option == OPTION_DECOMPRESS) {

                        decompressPlugin(new ZipInputStream(zipInputStream));

                    } else

                        if (option == OPTION_READ_INSTALLINFO) {

                            readPlugin(new ZipInputStream(zipInputStream),

                                entry.getName());

                        }

                zipInputStream.closeEntry();

            }

            zipInputStream.close();

        } catch (Exception e) {

            throw new InstallPackageServiceException(

                "Error reading the plugin", e);

        }

    }

    private void decompressFolderOfPluginFromPackage(InputStream is, String name)

        throws InstallPackageServiceException {

        ZipInputStream zipInputStream = new ZipInputStream(is);

        try {

            if (option == OPTION_INSTALL) {

            } else {

                if (option == OPTION_DECOMPRESS) {

                    decompressPlugin(zipInputStream);

                } else {

                    if (option == OPTION_READ_INSTALLINFO) {

                        readPlugin(zipInputStream, name);

                    }

                }

            }

            zipInputStream.close();

        } catch (Exception e) {

            throw new InstallPackageServiceException(

                "Error reading the plugin", e);

        }

    }

    private void readPlugin(ZipInputStream zipInputStream, String zipEntryName)

        throws ZipException, IOException, InstallerInfoFileException {

        ZipEntry entry = null;

        int installerInfoNumber = zipEntriesMap.size();

        while ((entry = zipInputStream.getNextEntry()) != null) {

            logger.debug("Extracting: " + entry.getName());

            if (entry.getName().endsWith(File.separator + "package.info")) {

                PackageInfo installerInfo = readInstallInfo(zipInputStream);

                zipEntriesMap.put(installerInfo, zipEntryName);

                readedIinstallerInfos.add(installerInfo);

            }

            zipInputStream.closeEntry();

        }

        // zipInputStream.close();

        if (installerInfoNumber == zipEntriesMap.size()) {

            PackageInfo installerInfo = new DefaultPackageInfo();

            installerInfo.setCode(zipEntryName);

            installerInfo.setName(zipEntryName);

            zipEntriesMap.put(installerInfo, zipEntryName);

            readedIinstallerInfos.add(installerInfo);

        }

    }

    private void decompressPlugin(ZipInputStream zipInputStream)

        throws ZipException, IOException,

        InstallerInfoFileException {

        ZipEntry entry = null;

        byte data[] = new byte[BUFFER];

        int count;

        while ((entry = zipInputStream.getNextEntry()) != null) {

            logger.debug("Extracting: " + entry.getName());

            File file =

                new File(outputDirectory.getAbsolutePath() + File.separator

                    + entry.getName());

            if (file.exists()) {

                delete(file);

            }

            if (entry.isDirectory()) {

                file.mkdir();

            } else {

                createParentFolder(file);

                FileOutputStream fos = new FileOutputStream(file);

                while ((count = zipInputStream.read(data, 0, BUFFER)) != -1) {

                    fos.write(data, 0, count);

                }

                fos.flush();

                fos.close();

            }

        }

    }

    private void createParentFolder(File file) {

        File parentFile = file.getParentFile();

        if (!parentFile.exists()) {

            createParentFolder(parentFile);

            parentFile.mkdir();

        }

    }

    public boolean delete(File dir) {

        if (dir.isDirectory()) {

            String[] children = dir.list();

            for (int i = 0; i < children.length; i++) {

                boolean success = delete(new File(dir, children[i]));

                if (!success) {

                    return false;

                }

            }

        }

        return dir.delete();

    }

    public PackageInfo readInstallerInfo(InputStream is)

        throws InstallerInfoFileException {

        try {

            return readInstallInfo(new ZipInputStream(is));

        } catch (IOException e) {

            throw new InstallerInfoFileException("error_reading_installerinfo",

                e);

        }

    }

    private PackageInfo readInstallInfo(ZipInputStream zipInputStream)

        throws IOException, InstallerInfoFileException {

        int count;

        byte data[] = new byte[BUFFER];

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        while ((count = zipInputStream.read(data, 0, BUFFER)) != -1) {

            out.write(data, 0, count);

        }

        out.flush();

        DefaultPackageInfo installerInfo = new DefaultPackageInfo();

        InstallerInfoFileReader installerInfoFileReader =

            new InstallerInfoFileReader();

        installerInfoFileReader.read(installerInfo, new ByteArrayInputStream(

            out.toByteArray()));

        return installerInfo;

    }

}