Application: gvSIG desktop

package org.gvsig.fmap.dal.spi;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.nio.file.FileSystem;

import java.nio.file.FileSystems;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.StandardCopyOption;

import java.util.Collections;

import java.util.Objects;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.AbstractDataResource;

import org.gvsig.tools.resourcesstorage.AbstractResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage.Resource;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ZipResourcesStorage extends AbstractResourcesStorage {

    private static final Logger LOGGER = LoggerFactory.getLogger(ZipResourcesStorage.class);

    public class ZipFileResource

            extends AbstractDataResource

            implements Resource {

        private class ResourceInputStream extends InputStream {

            @Override

            public int read() throws IOException {

                return in.read();

            }

            @Override

            public void close() throws IOException {

                ZipFileResource.this.close();

            }

        }

        private class ResourceOutputStream extends OutputStream {

            @Override

            public void write(int b) throws IOException {

                out.write(b);

            }

            @Override

            public void flush() throws IOException {

                out.flush();

            }

            @Override

            public void close() throws IOException {

                ZipFileResource.this.close();

            }

        }

        private final File zipFile;

        private final String tableName;

        private final String resourceName;

        private ZipFile zip;

        private InputStream in;

        private ByteArrayOutputStream out;

        public ZipFileResource(File zipFile, String tableName, String resourceName) {

            this.zipFile = zipFile;

            this.tableName = tableName;

            this.resourceName = resourceName;

            this.zip = null;

            this.in = null;

            this.out = null;

            if (StringUtils.isBlank(this.tableName)) {

                LOGGER.warn("The table name is empty (URL=" + this.getURL() + ").");

            }

            if (StringUtils.isBlank(this.resourceName)) {

                LOGGER.warn("The resource name is empty (URL=" + this.getURL() + ").");

            }

        }

        public String getName() {

          return this.resourceName;

        }

        @Override

        public boolean isReadOnly() {

            return false;

        }

        @Override

        public final URL getURL() {

            try {

                return new URL("jar:" + this.zipFile.toURI().toString() + "!/" + this.tableName + "." + this.resourceName);

            } catch (Exception ex) {

                return null;

            }

        }

        @Override

        public boolean exists() {

            try {

                if (!this.zipFile.exists()) {

                    return false;

                }

                ZipFile z = new ZipFile(zipFile);

                try {

                    ZipEntry entry = z.getEntry(this.tableName + "." + this.resourceName);

                    if (entry == null) {

                        return false;

                    }

                    return true;

                } finally {

                    IOUtils.closeQuietly(z);

                }

            } catch (Exception ex) {

                LOGGER.warn("Can't access to the resource (" + Objects.toString(this.getURL()) + ").", ex);

                return false;

            }

        }

        @Override

        public InputStream asInputStream() throws IOException {

            if (!this.zipFile.exists()) {

                return null;

            }

            if (this.in != null || this.out != null) {

                throw new IllegalStateException("Resource is already open (" + this.zipFile.toString() + "!" + this.tableName + ")");

            }

            try {

                if (this.zip == null) {

                    this.zip = new ZipFile(zipFile);

                }

                ZipEntry entry = this.zip.getEntry(this.tableName + "." + this.resourceName);

                if (entry == null) {

                    return null;

                }

                this.in = this.zip.getInputStream(entry);

                return new ResourceInputStream();

            } catch (Exception ex) {

                LOGGER.warn("Can't create input stream (" + Objects.toString(this.getURL()) + ").", ex);

                return null;

            }

        }

        @Override

        public OutputStream asOutputStream() throws IOException {

            if (this.in != null || this.out != null) {

                throw new IllegalStateException("Resource is already open (" + Objects.toString(this.getURL()) + ").");

            }

            this.out = new ByteArrayOutputStream();

            return new ResourceOutputStream();

        }

        @Override

        public void close() {

            if (this.in != null) {

                IOUtils.closeQuietly(this.in);

                this.in = null;

            }

            if (this.out != null) {

                ByteArrayInputStream contents = new ByteArrayInputStream(this.out.toByteArray());

                try {

                    this.updateZipEntry(zipFile, this.tableName + "." + this.resourceName, contents);

                } catch (Exception ex) {

                    LOGGER.warn("Can't write resource (" + Objects.toString(this.getURL()) + ").", ex);

                } finally {

                    IOUtils.closeQuietly(contents);

                    IOUtils.closeQuietly(this.out);

                    this.out = null;

                }

            }

            if (this.zip != null) {

                IOUtils.closeQuietly(this.zip);

                this.zip = null;

            }

        }

        private void updateZipEntry(File zip, String entryName, InputStream entryContents) throws URISyntaxException, IOException {

            FileSystem zipfs = null;

            try {

                URI zipfsuri = new URI("jar:" + zip.toURI().toString());

                zipfs = FileSystems.newFileSystem(zipfsuri, Collections.singletonMap("create", "true"));

                Path entryPath = zipfs.getPath(entryName);

                Files.copy(entryContents, entryPath, StandardCopyOption.REPLACE_EXISTING);

            } finally {

                IOUtils.closeQuietly(zipfs);

            }

        }

    }

    private final File zipFile;

    private final String tableName;

    public ZipResourcesStorage(String pathName, String tableName) {

        this.zipFile = new File(pathName + ".gvres");

        this.tableName = tableName;

    }

    public static boolean existsStorage(String pathName) {

        File theZipFile = new File(pathName + ".gvres");

        return theZipFile.exists();

    }

    @Override

    public Resource getResource(String resourceName) {

        ZipFileResource res = new ZipFileResource(

                this.zipFile,

                this.tableName,

                resourceName

        );

        return res;

    }

    @Override

    public boolean isEmpty() {

        return !this.zipFile.exists();

    }

}