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.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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @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 readInstallInfo(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 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), entry.getName());

                                }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 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, String zipEntryName) 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;

        }        

}