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

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

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

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.io.output.NullOutputStream;

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

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

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

import org.gvsig.fmap.dal.store.jdbc.exception.SQLRuntimeException;

import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;

import org.gvsig.fmap.dal.store.jdbc2.OperationsFactory;

import org.gvsig.fmap.dal.store.jdbc2.spi.operations.RetrieveValueOperation;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.resourcesstorage.AbstractResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.util.CachedValue;

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

    public static final String TABLENAME_SERVER_EXPLORER_MARK = "$ServerExplorer";

    private final JDBCHelper helper;

    private static class ExistsResourcesCache extends CachedValue<Map<String,Boolean>> {

        @Override

        protected void reload() {

            LOGGER.info("reload ExistsResourcesCache");

            this.setValue(new HashMap<>());

        }        

    }

    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 String name;

        private final JDBCResourcesStorage storage;

        private InputStream in;

        private OutputStream out;

        public DataBaseResource(JDBCResourcesStorage storage, String name) {

            this.storage = storage;                    

            this.name = name;

        }

        @Override

        public String getName() {

          return name;

        }

        private JDBCStoreParameters getStoreParameters() {

            return this.storage.resourcesStoreParameters;

        }

        private String getTableName() {

            return this.storage.tableName;

        }

        private Map<String,Boolean> getExistsResourcesCache() {

            return  this.storage.existsResourcesCache.get();

        }

        @Override

        public boolean isReadOnly() {

            return this.storage.readonly;

        }

        @Override

        public URL getURL() {

            try {

                String url = this.getStoreParameters().getUrl();

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

            } catch (Throwable ex) {

                return null;

            }

        }

        private byte[] retrieveResource() throws Exception {

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            String filter;

            if (StringUtils.equalsIgnoreCase(this.getTableName(), TABLENAME_SERVER_EXPLORER_MARK)) {

                filter = builder.eq(

                        builder.column(FIELD_RESOURCES_NAME),

                        builder.constant(this.name)

                ).toString();

            } else {

                filter = builder.eq(

                        builder.column(FIELD_RESOURCES_NAME),

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

                ).toString();

            }

            OperationsFactory operations = this.storage.helper.getOperations();

            RetrieveValueOperation op = operations.createRetrieveValue(

                    operations.createTableReference(this.getStoreParameters()),

                    filter,

                    null, //order

                    FIELD_RESOURCES_RESOURCE

            );

            return (byte[] ) op.perform();

        }

        private byte[] retrieveResource0() throws Exception {

            FeatureStore store = null;

            try {

                DataManager dataManager = DALLocator.getDataManager();

                store = (FeatureStore) dataManager.openStore(

                        this.getStoreParameters().getDataStoreName(),

                        this.getStoreParameters()

                );

                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                String filter;

                if (StringUtils.equalsIgnoreCase(this.getTableName(), TABLENAME_SERVER_EXPLORER_MARK)) {

                    filter = builder.eq(

                            builder.column(FIELD_RESOURCES_NAME),

                            builder.constant(this.name)

                    ).toString();

                } else {

                    filter = builder.eq(

                            builder.column(FIELD_RESOURCES_NAME),

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

                    ).toString();

                }

                Feature feature = store.findFirst(filter);

                if (feature == null) {

                    return null;

                }

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

                return resource;

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

        }

        @Override

        public boolean exists() {

//            FeatureStore store = null;

            try {

                FoldersManager fm = ToolsLocator.getFoldersManager();

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

                String key_s = key.getLeft() + "/"+ key.getRight();

                Map<String, Boolean> erc = this.getExistsResourcesCache();

                if( erc.containsKey(key_s) ) {

                    return this.getExistsResourcesCache().get(key_s);

                }

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

                if( f.exists() ) {

                  return true;

                }

                byte[] resource = retrieveResource();

                boolean exists = resource!=null;

                if( resource!=null ) {

                    putResourceInCache(resource);

                }

                this.getExistsResourcesCache().put(key_s, exists);

                return exists;

            } 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.getStoreParameters().getDataStoreName(),

                        this.getStoreParameters()

                );

                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                String filter;

                if (StringUtils.equalsIgnoreCase(this.getTableName(), TABLENAME_SERVER_EXPLORER_MARK)) {

                    filter = builder.eq(

                            builder.column(FIELD_RESOURCES_NAME),

                            builder.constant(this.name)

                    ).toString();

                } else {

                    filter = builder.eq(

                            builder.column(FIELD_RESOURCES_NAME),

                            builder.constant(this.getTableName() + "." + 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.getStoreParameters().toByteArray();

            ImmutablePair<String, String> r;

            if (StringUtils.equalsIgnoreCase(this.getTableName(), TABLENAME_SERVER_EXPLORER_MARK)) {

                r = new ImmutablePair<>(

                        DigestUtils.md5Hex(data), 

                        this.name

                );

            } else {

                r = new ImmutablePair<>(

                        DigestUtils.md5Hex(data), 

                        this.getTableName()+"."+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);             

              IOUtils.closeQuietly(os);

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

              byte[] data = this.getStoreParameters().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 void putResourceInCache(byte[] resource) {

            FoldersManager fm = ToolsLocator.getFoldersManager();

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

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

            FileOutputStream os = null;

            File f2 = null;

            try {

                FileUtils.forceMkdir(f.getParentFile());

                os = new FileOutputStream(f);

                IOUtils.write(resource, os);

                IOUtils.closeQuietly(os);

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

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

                os = new FileOutputStream(f2);

                IOUtils.write(data, os);

            } catch (IOException ex) {

                FileUtils.deleteQuietly(f);

                FileUtils.deleteQuietly(f2);

            } finally {

                IOUtils.closeQuietly(os);

            }

        }

        private InputStream getInputStream() throws IOException {

            try {

                byte[] resource = retrieveResource();

                InputStream is = new ByteArrayInputStream(resource);

                return is;

            } catch (Throwable ex) {

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

            }

            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() + ").");

            }

            if( this.isReadOnly()) {

                this.out = NullOutputStream.NULL_OUTPUT_STREAM;

            } else {

                this.out = new ByteArrayOutputStream();

            }

            return new ResourceOutputStream();

        }

        @Override

        public void close() {

            if (this.in != null) {

                IOUtils.closeQuietly(this.in);

                this.in = null;

            }

            if (!this.isReadOnly()&& this.out != null) {

                FeatureStore store = null;

                try {

                    DataManager dataManager = DALLocator.getDataManager();

                    store = (FeatureStore) dataManager.openStore(

                            this.getStoreParameters().getDataStoreName(),

                            this.getStoreParameters()

                    );

                    store.edit();

                    ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                    String filter;

                    if (StringUtils.equalsIgnoreCase(this.getTableName(), TABLENAME_SERVER_EXPLORER_MARK)) {

                        filter = builder.eq(

                                builder.column(FIELD_RESOURCES_NAME),

                                builder.constant(this.name)

                        ).toString();

                    } else {

                        filter = builder.eq(

                                builder.column(FIELD_RESOURCES_NAME),

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

                        ).toString();

                    }

                    Feature feature = store.findFirst(filter);

                    EditableFeature efeature;

                    if (feature == null) {

                        efeature = store.createNewFeature();

                        if (StringUtils.equalsIgnoreCase(this.getTableName(), TABLENAME_SERVER_EXPLORER_MARK)) {

                            efeature.set(FIELD_RESOURCES_NAME, this.name);

                        } else {

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

                        }

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

                        store.insert(efeature);

                    } else {

                        efeature = feature.getEditable();

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

                        store.update(efeature);

                    }

                    store.finishEditing();

                    removeCache();

                } catch (SQLRuntimeException ex) {

                    FeatureStore.cancelEditingQuietly(store);

                    if( !ex.isTableOrViewNotFound() ) { 

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

                    }

                } catch (Throwable ex) {

                    FeatureStore.cancelEditingQuietly(store);

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

                } finally {

                    DisposeUtils.disposeQuietly(store);

                }

            }

        }

    }

    private final ResourcesStorage alternativeStorage;

    private final JDBCStoreParameters resourcesStoreParameters;

    private final String tableName;

    private final boolean readonly;

    private final ExistsResourcesCache existsResourcesCache;

    public JDBCResourcesStorage(

                JDBCHelper helper,

                ResourcesStorage alternativeStorage, 

                JDBCStoreParameters resourcesStoreParameters, 

                String tableName

        ) {

        this(helper, alternativeStorage, resourcesStoreParameters, tableName, false);

    }

    public JDBCResourcesStorage(

                JDBCHelper helper,

                ResourcesStorage alternativeStorage, 

                JDBCStoreParameters resourcesStoreParameters, 

                String tableName,

                boolean readonly

        ) {

        this.helper = helper;

        DisposeUtils.bind(this.helper);

        this.readonly = readonly;

        this.alternativeStorage = alternativeStorage;

        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;

        this.existsResourcesCache = new ExistsResourcesCache();

        this.existsResourcesCache.setExpireTime(60000); // 1 min

    }

    @Override

    public boolean isEmpty() {

        return this.resourcesStoreParameters == null;

    }

    @Override

    public List<String> getResourceNames() {

        if( this.alternativeStorage!=null ) {

            List<String> names = this.alternativeStorage.getResourceNames();

            return names;

        }

        if (this.resourcesStoreParameters == null) {

            return Collections.EMPTY_LIST;

        }

        FeatureStore store = null;

        try {

            DataManager dataManager = DALLocator.getDataManager();

            Set<String> typeNames = new HashSet<>();

            store = (FeatureStore) dataManager.openStore(

                    this.resourcesStoreParameters.getDataStoreName(),

                    this.resourcesStoreParameters

            );

            FeatureSet featureSet = store.getFeatureSet();

            for (Feature feature : featureSet) {

                String resName = feature.getString(FIELD_RESOURCES_NAME);

                if (StringUtils.equalsIgnoreCase(tableName, TABLENAME_SERVER_EXPLORER_MARK)) {

                    typeNames.add(resName);

                } else {

                    String resTypeName = FilenameUtils.getExtension(resName);

                    typeNames.add(resTypeName);

                }

            }

            return new ArrayList<>(typeNames);

        } catch (Throwable ex) {

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

            return null;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public Resource getResource(String name) {

        if( this.alternativeStorage!=null ) {

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

            if( r.exists() ) {

                return r;

            }

        }

        if (this.resourcesStoreParameters == null) {

            return null;

        }

        return new DataBaseResource(this,name);

    }

    @Override

    public List<Resource> getResources(String name) {

        if (this.resourcesStoreParameters == null) {

            return null;

        }

        if( this.alternativeStorage!=null ) {

            List<Resource> r = this.alternativeStorage.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,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 add(String resourceName, InputStream is) {

        DataBaseResource res = new DataBaseResource(this, resourceName);

        try {

            IOUtils.copy(is, res.asOutputStream());

            res.close();

            is.close();

            return true;

        } catch (IOException ex) {

            return false;

        }

    }

    @Override

    public boolean remove(String resourceName) {

        if( this.alternativeStorage!=null ) {

            try {

                this.alternativeStorage.remove(resourceName);

            } catch (Exception e) {

                //Do nothing

            }

        }

        if (this.resourcesStoreParameters == null) {

            return false;

        }

        DataBaseResource resource = new DataBaseResource(this,resourceName);

        return resource.remove();

    }

    void clearCache() throws IOException {

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

        FoldersManager fm = ToolsLocator.getFoldersManager();

        File f = fm.getTemporaryFile("resources-storage", "jdbc", DigestUtils.md5Hex(data));

        FileUtils.deleteDirectory(f);

    }

    @Override

    protected void doDispose() throws BaseException {

        super.doDispose();

        DisposeUtils.disposeQuietly(this.helper);

    }

}