Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2020 gvSIG Association.

 *

 * 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 3

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.store.jdbc2.spi;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.URL;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.codec.digest.DigestUtils;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_RESOURCES_NAME;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_RESOURCES_RESOURCE;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_RESOURCES_NAME;

import org.gvsig.fmap.dal.feature.EditableFeature;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.resourcesstorage.AbstractResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class JDBCResourcesStorage extends AbstractResourcesStorage {

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

    private static class DataBaseResource implements Resource {

        private class ResourceInputStream extends InputStream {

            @Override

            public int read() throws IOException {

                return in.read();

            }

            @Override

            public void close() throws IOException {

                DataBaseResource.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 {

                DataBaseResource.this.close();

            }

        }

        private final JDBCStoreParameters storeParameters;

        private final String tableName;

        private final String name;

        private InputStream in;

        private ByteArrayOutputStream out;

        public DataBaseResource(JDBCStoreParameters storeParameters, String tableName, String name) {

            this.storeParameters = storeParameters;

            this.tableName = tableName;

            this.name = name;

        }

        @Override

        public String getName() {

          return name;

        }

        @Override

        public boolean isReadOnly() {

            return false;

        }

        @Override

        public URL getURL() {

            try {

                String url = this.storeParameters.getUrl();

                return new URL(url + "&tableName=" + this.tableName + "&resourceName=" + this.name);

            } catch (Throwable ex) {

                return null;

            }

        }

        @Override

        public boolean exists() {

            FeatureStore store = null;

            try {

                FoldersManager fm = ToolsLocator.getFoldersManager();

                Pair<String, String> key = this.getCacheID();

                File f = fm.getTemporaryFile("resources-storage","jdbc", key.getLeft(), key.getRight());

                if( f.exists() ) {

                  return true;

                }

                DataManager dataManager = DALLocator.getDataManager();

                store = (FeatureStore) dataManager.openStore(

                        this.storeParameters.getDataStoreName(),

                        this.storeParameters

                );

                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                String filter = builder.eq(

                        builder.column(FIELD_RESOURCES_NAME),

                        builder.constant(this.tableName+"."+this.name)

                ).toString();

                Feature feature = store.findFirst(filter);

                return feature!=null;

            } catch (Throwable ex) {

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

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

            return false;

        }

        public boolean remove() {

            FeatureStore store = null;

            try {

                FoldersManager fm = ToolsLocator.getFoldersManager();

                Pair<String, String> key = this.getCacheID();

                File f = fm.getTemporaryFile("resources-storage","jdbc", key.getLeft(), key.getRight());

                if( f.exists() ) {

                  f.delete();

                }

                DataManager dataManager = DALLocator.getDataManager();

                store = (FeatureStore) dataManager.openStore(

                        this.storeParameters.getDataStoreName(),

                        this.storeParameters

                );

                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                String filter = builder.eq(

                        builder.column(FIELD_RESOURCES_NAME),

                        builder.constant(this.tableName+"."+this.name)

                ).toString();

                Feature feature = store.findFirst(filter);

                if(feature != null){

                    store.edit();

                    store.delete(feature);

                    store.finishEditing();

                    return true;

                }

                return false;

            } catch (Throwable ex) {

                FeatureStore.cancelEditingQuietly(store);

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

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

            return false;

        }

        private Pair<String,String> getCacheID() {

          byte[] data = this.storeParameters.toByteArray();

          ImmutablePair<String, String> r = new ImmutablePair<>(

                  DigestUtils.md5Hex(data), 

                  this.tableName+"."+this.name

          );

          return r;

        }

        private boolean removeCache() {

          FoldersManager fm = ToolsLocator.getFoldersManager();

          Pair<String, String> key = this.getCacheID();

          File f = fm.getTemporaryFile("resources-storage","jdbc", key.getLeft(), key.getRight());

          if( f.exists() ) {

              try {

                  FileUtils.forceDelete(f);

              } catch (IOException ex) {

                  return false;

              }

          }

          return true;

        }

        private InputStream getInputStreamFromCache() {

          FoldersManager fm = ToolsLocator.getFoldersManager();

          Pair<String, String> key = this.getCacheID();

          File f = fm.getTemporaryFile("resources-storage","jdbc", key.getLeft(), key.getRight());

          if( !f.exists() ) {

            InputStream is = null;

            FileOutputStream os = null;

            File f2 = null;

            try {

              is = this.getInputStream();

              if (is==null) {

                  return null;

              }

              FileUtils.forceMkdir(f.getParentFile());

              os = new FileOutputStream(f);

              IOUtils.copy(is, os);              

              f2 = fm.getTemporaryFile("resources-storage","jdbc", key.getLeft(), "parameters");              

              byte[] data = this.storeParameters.toByteArray();

              os = new FileOutputStream(f2);

              IOUtils.write(data, os);

            } catch (IOException ex) {

              FileUtils.deleteQuietly(f);

              FileUtils.deleteQuietly(f2);

              return null;

            } finally {

              IOUtils.closeQuietly(is);

              IOUtils.closeQuietly(os);

            }

          }

          InputStream is = null;

          try {

            is = new FileInputStream(f);

          } catch (FileNotFoundException ex) {

          }

          return is;

        }

        private InputStream getInputStream() throws IOException {

            FeatureStore store = null;

            try {

                DataManager dataManager = DALLocator.getDataManager();

                store = (FeatureStore) dataManager.openStore(

                        this.storeParameters.getDataStoreName(),

                        this.storeParameters

                );

                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                String filter = builder.eq(

                        builder.column(FIELD_RESOURCES_NAME),

                        builder.constant(this.tableName+"."+this.name)

                ).toString();

                Feature feature = store.findFirst(filter);

                if (feature == null) {

                    return null;

                }

                byte[] resource = feature.getByteArray(FIELD_RESOURCES_RESOURCE);

                InputStream is = new ByteArrayInputStream(resource);

                return is;

            } catch (Throwable ex) {

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

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

            return null;

        }

        @Override

        public InputStream asInputStream() throws IOException {

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

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

            }

            InputStream is = this.getInputStreamFromCache();

            if( is==null ) {

                is = this.getInputStream();

                if ( is==null) {

                    return null;

                }

            }

            this.in = is;

            return new ResourceInputStream();

        }

        @Override

        public OutputStream asOutputStream() throws IOException {

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

                throw new IllegalStateException("Resource is already open (" + 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) {

                FeatureStore store = null;

                try {

                    DataManager dataManager = DALLocator.getDataManager();

                    store = (FeatureStore) dataManager.openStore(

                            this.storeParameters.getDataStoreName(),

                            this.storeParameters

                    );

                    store.edit();

                    ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                    String filter = builder.eq(

                            builder.column(FIELD_RESOURCES_NAME),

                            builder.constant(this.tableName+"."+this.name)

                    ).toString();

                    Feature feature = store.findFirst(filter);

                    EditableFeature efeature;

                    if (feature == null) {

                        efeature = store.createNewFeature();

                        efeature.set(FIELD_RESOURCES_NAME, this.tableName+"."+this.name);

                        efeature.set(FIELD_RESOURCES_RESOURCE, this.out.toByteArray());

                        store.insert(efeature);

                    } else {

                        efeature = feature.getEditable();

                        efeature.set(FIELD_RESOURCES_RESOURCE, this.out.toByteArray());

                        store.update(efeature);

                    }

                    store.finishEditing();

                    removeCache();

                } catch (Throwable ex) {

                    FeatureStore.cancelEditingQuietly(store);

                    LOGGER.warn("Can't write the resoure '" + this.getURL() + "'.", ex);

                } finally {

                    DisposeUtils.disposeQuietly(store);

                }

            }

        }

    }

    private final ResourcesStorage alternativeStorge;

    private final JDBCStoreParameters resourcesStoreParameters;

    private final String tableName;

    public JDBCResourcesStorage(ResourcesStorage alternativeStorge, JDBCStoreParameters resourcesStoreParameters, String tableName) {

        this.alternativeStorge = alternativeStorge;

        if( StringUtils.equals(TABLE_RESOURCES_NAME, tableName) ) {

            // No podemos buscar recursos de la tabla de recursos, ya que si no

            // al abrise la tabla de recursos entraria en bucle.

            this.resourcesStoreParameters = null;

        } else {

            this.resourcesStoreParameters = resourcesStoreParameters;

        }

        this.tableName = tableName;

    }

    @Override

    public boolean isEmpty() {

        return this.resourcesStoreParameters == null;

    }

    @Override

    public Resource getResource(String name) {

        if( this.alternativeStorge!=null ) {

            Resource r = this.alternativeStorge.getResource(name);

            if( r.exists() ) {

                return r;

            }

        }

        if (this.resourcesStoreParameters == null) {

            return null;

        }

        return new DataBaseResource(

                this.resourcesStoreParameters, 

                this.tableName, 

                name

        );

    }

    @Override

    public List<Resource> getResources(String name) {

        if (this.resourcesStoreParameters == null) {

            return null;

        }

        if( this.alternativeStorge!=null ) {

            List<Resource> r = this.alternativeStorge.getResources(name);

            if( r!=null && !r.isEmpty() ) {

                return r;

            }

        }

        FeatureStore store = null;

        try {

            DataManager dataManager = DALLocator.getDataManager();

            store = (FeatureStore) dataManager.openStore(

                    this.resourcesStoreParameters.getDataStoreName(),

                    this.resourcesStoreParameters

            );

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            List<ResourcesStorage.Resource> ress = new ArrayList<>();

            int n = 0;

            while (true) {

                String multiresourceName;

                if (n == 0) {

                    multiresourceName = name;

                } else {

                    multiresourceName = String.valueOf(n) + "." + name ;

                }

                String filter = builder.eq(

                        builder.column(FIELD_RESOURCES_NAME),

                        builder.constant(this.tableName+"."+multiresourceName)

                ).toString();

                Feature feature = store.findFirst(filter);

                if( feature==null ) {

                    break;

                }

                ress.add(new DataBaseResource(

                        this.resourcesStoreParameters, 

                        this.tableName,

                        multiresourceName

                    )

                );

                n++;

            }

            if (ress.isEmpty()) {

                return null;

            }

            return ress;

        } catch (Throwable ex) {

            LOGGER.warn("Can't get resources for '" + this.resourcesStoreParameters.getUrl()+"&resourceName="+name + "'.", ex);

            return null;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public boolean remove(String resourceName) {

        if( this.alternativeStorge!=null ) {

            try {

                this.alternativeStorge.remove(resourceName);

            } catch (Exception e) {

                //Do nothing

            }

        }

        if (this.resourcesStoreParameters == null) {

            return false;

        }

        DataBaseResource resource = new DataBaseResource(

                this.resourcesStoreParameters,

                this.tableName, 

                resourceName

        );

        return resource.remove();

    }

}