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, see <https://www.gnu.org/licenses/>.

 *

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

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.apache.commons.lang3.StringUtils;

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

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

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.SupportTransactions;

import org.gvsig.fmap.dal.exception.DataException;

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

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

import org.gvsig.fmap.dal.spi.DataTransactionServices;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.observer.BaseNotification;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultTransaction extends AbstractDisposable implements DataTransactionServices {

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

    private final String code;

    private final Map<String,DataServerExplorer> explorers;

    private final Map<String,ConnectionService> connections;

    private Map<String,Pair<DataStore,Boolean>> stores;

    private boolean inProgress;

    private List<Disposable> disposables;

    private ObservableHelper observableHelper;

    private Set<SupportTransactions> supportTransactions;

    public DefaultTransaction() {

        this.code = UUID.randomUUID().toString().replace("-", "");

        this.stores = new HashMap<>();

        this.explorers = new HashMap<>();

        this.disposables = new ArrayList<>();

        this.supportTransactions = new HashSet<>();

        this.inProgress = false;

        this.connections = new HashMap<>();

        this.observableHelper = new ObservableHelper();

    }

    @Override

    public String getCode() {

        return this.code;

    }

    @Override

    public void begin() throws DataException {

        if( this.inProgress ) {

            throw new IllegalStateException("Transaction already started.");

        }

        this.observableHelper.notifyObservers(this, new BaseNotification("BEGIN", null));

        this.inProgress = true;

    }

    @Override

    public void commit() throws DataException {

        if (!this.isInProgress()) {

            throw new IllegalStateException("Can't commit transaction without begin.");

        }

        try {

            LOGGER.debug("commit in "+this.getCode());

            int retries = 5;

            boolean needretry = false;

            while(retries > 0) {

                needretry = false;

                Collection<Pair<DataStore, Boolean>> theStores = new ArrayList(stores.values());

                for (Pair<DataStore, Boolean> item : theStores) {

                    DataStore store = getStore(item);

                    if (store instanceof FeatureStore) {

                        FeatureStore fstore = (FeatureStore) store;

                        if (fstore != null && fstore.getMode() != MODE_QUERY) {

                            LOGGER.debug("commit: finishEditing "+store.getFullName());

                            fstore.finishEditing();

                            needretry=true;

                        }

                    }

                }

                if( !needretry ) {

                    break;

                }

                LOGGER.debug("commit: retry store finish editing");

                retries--;

            }

            for (ConnectionService connection : this.connections.values()) {

                connection.finish();

            }

            this.observableHelper.notifyObservers(this, new BaseNotification("COMMIT", null));

            this.inProgress = false;

        } finally {

            LOGGER.debug("commit out "+this.getCode());

        }

    }

    @Override

    public void rollback() throws DataException {

        if( !this.isInProgress() ) {

            throw new IllegalStateException("Can't rollback transaction without begin.");

        }

//        LOGGER.info("rollback in");

        for (Pair<DataStore, Boolean> item : stores.values()) {

            DataStore store = getStore(item);

            if( store instanceof FeatureStore ) {

                FeatureStore fstore = (FeatureStore) store;

                if( fstore.getMode() != MODE_QUERY) {

                    fstore.cancelEditing();

                }

            }

        }

        for (ConnectionService connection : this.connections.values()) {

            connection.abort();

        }

        this.observableHelper.notifyObservers(this, new BaseNotification("ROLLBACK", null));

        this.inProgress = false;

//        LOGGER.info("rollback out");

    }

    @Override

    public void rollbackQuietly() {

        try {

            this.rollback();

        } catch(Exception ex) {

            // Do nothing

        }

    }

    @Override

    public void add(DataStore store) {

        add(store, null, true);

    }

    @Override

    public void add(DataStore store, String id) {

        this.add(store, id, true);

    }

    @Override

    public void add(DataStore store, boolean local) {

        this.add(store, null, local);

    }

    @Override

    public void add(DataStore store, String id, boolean local) {

        if (store == null) {

            throw new IllegalArgumentException("The store is required.");

        }

//        try {

//            LOGGER.info("add in "+this.getCode()+" "+store.getFullName());

            String theId = id;

            if (StringUtils.isBlank(id)) {

                theId = store.hashCode() + "@" + store.getFullName();

            } else {

                DataStore theStore = getStore(this.stores.get(theId));

                if (theStore != null) {

                    if (theStore == store) {

                        return;

                    }

                    throw new IllegalArgumentException("The id '" + id + "' is already used.");

                }

            }

            if (store instanceof SupportTransactions) {

                ((SupportTransactions) store).setTransaction(this);

            }

            if (!local) {

                DisposeUtils.bind(store);

            }

            this.stores.put(theId, new MutablePair<>(store, local));

//        } finally {

//            LOGGER.info("add out");

//        }

    }

    @Override

    public FeatureStore getFeatureStore(String id) {

        FeatureStore store = (FeatureStore) this.getStore(this.stores.get(id));

        if(store == null){

            for (Pair<DataStore, Boolean> value : stores.values()) {

                DataStore currentStore = this.getStore(value);

                if(StringUtils.equalsIgnoreCase(id, currentStore.getName())){

                    if(store != null){

                        if(!StringUtils.equals(store.getFullName(), currentStore.getFullName())){

                            return null;

                        }

                    }

                    store = (FeatureStore) this.getStore(value);

                }

            }

        }

        return store;

    }

    @Override

    public void add(DataServerExplorer explorer) {

        this.add(explorer, null, true);

    }

    @Override

    public void add(DataServerExplorer explorer, String id) {

        this.add(explorer, id, true);

    }

    @Override

    public void add(DataServerExplorer explorer, boolean local) {

        this.add(explorer, null, local);

    }

    @Override

    public void add(DataServerExplorer explorer, String id, boolean local) {

        if(explorer == null){

            throw new IllegalArgumentException("The explorer is required.");

        }

        String theId = id;

        if( StringUtils.isBlank(id) ) {

            theId = String.valueOf(explorer.hashCode());

        } else {

            DataServerExplorer theExplorer = this.explorers.get(theId);

            if(theExplorer!=null ){

                if( theExplorer==explorer ) {

                    return;

                }

                throw new IllegalArgumentException("The id '"+id+"' is already used.");

            }

        }

        if( explorer instanceof SupportTransactions ) {

            ((SupportTransactions) explorer).setTransaction(this);

        }

        if(!local){

            DisposeUtils.bind(explorer);

        }

        this.explorers.put(theId,explorer);

    }

    @Override

    public DataServerExplorer getServerExplorer(String id) {

        return this.explorers.get(id);

    }

    @Override

    public void add(Disposable resource) throws DataException {

        this.disposables.add(resource);

    }

    @Override

    public void add(SupportTransactions obj, boolean local) throws DataException {

        if(obj == null){

            throw new IllegalArgumentException("The transaction supplier is required.");

        }

        if(obj instanceof DataStore){

          this.add((DataStore)obj, local);

          return;

        }

        if(obj instanceof DataServerExplorer){

          this.add((DataServerExplorer)obj, local);

          return;

        }

        obj.setTransaction(this);

        if(!local){

            DisposeUtils.bind(obj);

        }

        this.supportTransactions.add(obj);

    }

    @Override

    public void remove(DataStore store) {

        if( this.inProgress && !DisposeUtils.isNullOrDisposed(store)){

            throw new IllegalStateException("Can't remove store from a in progress transaction.");

        }

//        try {

//            LOGGER.info("remove in");

            String id = null;

            for (Map.Entry<String, Pair<DataStore,Boolean>> entry : this.stores.entrySet()) {

                if( store == getStore(entry.getValue()) ) {

                    id = entry.getKey();

                    break;

                }

            }

            if( id==null ) {

                return;

            }

            if( store instanceof SupportTransactions ) {

                ((SupportTransactions) store).setTransaction(null);

            }

            this.stores.remove(id);

            DisposeUtils.dispose(store);

//        } finally {

//            LOGGER.info("remove in");

//        }

    }

    @Override

    public void remove(DataServerExplorer serverExplorer) {

        if( this.inProgress ) {

            throw new IllegalStateException("Can't remove server explorer from a in progress transaction.");

        }

        String id = null;

        for (Map.Entry<String, DataServerExplorer> entry : this.explorers.entrySet()) {

            if( serverExplorer == entry.getValue() ) {

                id = entry.getKey();

                break;

            }

        }

        if( id==null ) {

            return;

        }

        if( serverExplorer instanceof SupportTransactions ) {

            ((SupportTransactions) serverExplorer).setTransaction(null);

        }

        this.explorers.remove(id);

        DisposeUtils.dispose(serverExplorer);

    }

    @Override

    public boolean isInProgress() {

        return inProgress;

    }

    @Override

    public void doDispose() {

//        LOGGER.info("doDispose in "+this.getCode());

        if( this.inProgress ) {

            this.rollbackQuietly();

        }

        for (Pair<DataStore, Boolean> item : stores.values()) {

            DataStore store = getStore(item);

            if( store instanceof SupportTransactions ) {

                ((SupportTransactions) store).setTransaction(null);

            }

            DisposeUtils.disposeQuietly(store);

        }

        for (DataServerExplorer explorer : explorers.values()) {

            if( explorer instanceof SupportTransactions ) {

                ((SupportTransactions) explorer).setTransaction(null);

            }

            DisposeUtils.disposeQuietly(explorer);

        }

        for (Disposable resource : disposables) {

            if( resource instanceof SupportTransactions ) {

                ((SupportTransactions) resource).setTransaction(null);

            }

            DisposeUtils.disposeQuietly(resource);

        }

        for (SupportTransactions obj : supportTransactions) {

            obj.setTransaction(null);

            DisposeUtils.disposeQuietly(obj);

        }

        for (ConnectionService connection : this.connections.values()) {

            connection.dispose();

        }

        this.supportTransactions = null;

        this.disposables = null;

        this.stores = null;

//        LOGGER.info("doDispose out");

   }

    @Override

    public void close() throws Exception {

        this.dispose();

    }

    @Override

    public void addConnection(ConnectionService connection) {

        if( this.connections.containsKey(connection.getId()) ) {

            return;

        }

        this.connections.put(connection.getId(), connection);

    }

    @Override

    public ConnectionService getConnection(String id) {

        return this.connections.get(id);

    }

    @Override

    public void removeConnection(String id) {

        this.connections.remove(id);

    }

    @Override

    public boolean existsConnection(String id) {

        return this.connections.containsKey(id);

    }

    @Override

    public void addObserver(Observer obsrvr) {

        this.observableHelper.addObserver(obsrvr);

    }

    @Override

    public void deleteObserver(Observer obsrvr) {

        this.observableHelper.deleteObserver(obsrvr);

    }

    @Override

    public void deleteObservers() {

        this.observableHelper.deleteObservers();

    }

    @Override

    public boolean contains(DataServerExplorer explorer) {

        for (DataServerExplorer value : this.explorers.values()) {

            if(explorer == value){

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean contains(DataStore store) {

        for (Pair<DataStore, Boolean> item : stores.values()) {

            DataStore value = getStore(item);

            if(store == value){

                return true;

            }

        }

        return false;

    }

    private DataStore getStore(Pair<DataStore, Boolean> item) {

        if( item == null ) {

            return null;

        }

        return item.getLeft();

    }

}