Dépôt officiel du code source de l'ERP OpenConcerto

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 /*
 * Created on 7 mai 03
 */
package org.openconcerto.sql.model;

import org.openconcerto.sql.model.LoadingListener.StructureLoadingEvent;
import org.openconcerto.sql.model.graph.TablesMap;
import org.openconcerto.sql.utils.SQL_URL;
import org.openconcerto.utils.CollectionUtils;
import org.openconcerto.utils.NetUtils;
import org.openconcerto.utils.Tuple2.List2;
import org.openconcerto.utils.cc.CopyOnWriteMap;
import org.openconcerto.utils.cc.IClosure;
import org.openconcerto.utils.cc.ITransformer;
import org.openconcerto.utils.change.CollectionChangeEventCreator;

import java.security.AccessController;
import java.security.PrivilegedAction;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
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 java.util.concurrent.Callable;

import net.jcip.annotations.GuardedBy;

/**
 * Un serveur de base de donnée SQL. Meaning a system (eg mysql) on a certain host and port. Un
 * serveur permet d'accéder aux bases qui le composent (une base par défaut peut être spécifiée). De
 * plus il permet de spécifier un login/pass par défaut.
 * 
 * @author ilm
 * @see #getOrCreateBase(String)
 */
public final class SQLServer extends DBStructureItemJDBC {

    private static final IClosure<SQLDataSource> DSINIT_ERROR = new IClosure<SQLDataSource>() {
        @Override
        public void executeChecked(SQLDataSource input) {
            throw new IllegalStateException("Datasource should already be created");
        }
    };

    static private final <T> IClosure<? super T> coalesce(IClosure<? super T> o1, IClosure<? super T> o2) {
        // ternary operator makes Eclipse fail
        if (o1 != null)
            return o1;
        else
            return o2;
    }

    public static final DBSystemRoot create(final SQL_URL url) {
        return create(url, Collections.<String> emptySet(), null);
    }

    /**
     * Create a system root from the passed URL.
     * 
     * @param url an SQL URL.
     * @param rootsToMap the collection of {@link DBSystemRoot#setRootsToMap(Collection) roots to
     *        map}, in addition to <code>url.{@link SQL_URL#getRootName() getRootName()}</code>.
     * @param dsInit to initialize the datasource before any request (e.g. setting JDBC properties),
     *        can be <code>null</code>.
     * @return the new system root.
     */
    public static final DBSystemRoot create(final SQL_URL url, final Collection<String> rootsToMap, IClosure<SQLDataSource> dsInit) {
        return create(url, rootsToMap, false, dsInit);
    }

    public static final DBSystemRoot create(final SQL_URL url, final Collection<String> roots, final boolean setPath, IClosure<SQLDataSource> dsInit) {
        final DBSystemRoot res = create(url, new IClosure<DBSystemRoot>() {
            @Override
            public void executeChecked(DBSystemRoot input) {
                if (url.getRootName() != null) {
                    input.setRootToMap(url.getRootName());
                    input.addRootsToMap(roots);
                } else {
                    input.setRootsToMap(roots);
                }
            }
        }, dsInit);
        if (setPath) {
            final List<String> path = new ArrayList<String>(roots);
            if (url.getRootName() != null)
                path.add(0, url.getRootName());
            path.retainAll(res.getChildrenNames());
            if (path.size() > 0)
                res.setRootPath(path);
        }
        return res;
    }

    public static final DBSystemRoot create(final SQL_URL url, final IClosure<? super DBSystemRoot> systemRootInit, final IClosure<? super SQLDataSource> dsInit) {
        return new SQLServer(url.getSystem(), url.getServerName(), null, url.getLogin(), url.getPass(), systemRootInit, dsInit).getSystemRoot(url.getSystemRootName());
    }

    // *** Instance members

    // eg mysql, derby
    private final SQLSystem system;
    private final String login;
    private final String pass;
    private final IClosure<? super DBSystemRoot> systemRootInit;
    @GuardedBy("baseMutex")
    private CopyOnWriteMap<String, SQLBase> bases;
    private Object baseMutex = new String("base mutex");
    // linked to bases
    @GuardedBy("this")
    private String defaultBase;
    // linked to dsSet
    @GuardedBy("this")
    private SQLDataSource ds;
    @GuardedBy("this")
    private boolean dsSet;
    private final IClosure<? super SQLDataSource> dsInit;
    private final ITransformer<String, String> urlTransf;

    @GuardedBy("this")
    private String id;

    public SQLServer(SQLSystem system, String host) {
        this(system, host, null);
    }

    public SQLServer(SQLSystem system, String host, String port) {
        this(system, host, port, null, null);
    }

    public SQLServer(SQLSystem system, String host, String port, String login, String pass) {
        this(system, host, port, login, pass, null, null);
    }

    /**
     * Creates a new server.
     * 
     * @param system the database system.
     * @param host an IP address or DNS name.
     * @param port the port to connect to can be <code>null</code> to pick the system default.
     * @param login the default login to access database of this server, can be <code>null</code>.
     * @param pass the default password to access database of this server, can be <code>null</code>.
     * @param systemRootInit to initialize the system root in its constructor, can be
     *        <code>null</code>.
     * @param dsInit to initialize the datasource before any request (e.g. setting JDBC properties),
     *        must be thread-safe, can be <code>null</code>.
     */
    public SQLServer(SQLSystem system, String host, String port, String login, String pass, IClosure<? super DBSystemRoot> systemRootInit, IClosure<? super SQLDataSource> dsInit) {
        super(null, host);
        this.ds = null;
        this.dsSet = false;
        this.dsInit = dsInit;
        this.system = system;
        this.login = login;
        this.pass = pass;
        this.bases = null;
        this.systemRootInit = systemRootInit;
        this.urlTransf = this.getSQLSystem().getURLTransf(this);

        this.id = this.getName();

        // cannot refetch now as we don't have any datasource yet (see createSystemRoot())
    }

    private final CopyOnWriteMap<String, SQLBase> getBases() {
        synchronized (this.getTreeMutex()) {
            synchronized (this.baseMutex) {
                if (this.bases == null) {
                    this.checkDropped();
                    this.bases = new CopyOnWriteMap<String, SQLBase>();
                    this.refresh(null, true, true);
                }
                return this.bases;
            }
        }
    }

    /**
     * Signal that this server and its descendants will not be used anymore.
     */
    public final void destroy() {
        synchronized (this.getTreeMutex()) {
            if (!this.isDropped())
                this.dropped();
        }
    }

    @Override
    protected void onDrop() {
        synchronized (this) {
            if (this.ds != null)
                try {
                    this.ds.close();
                } catch (SQLException e) {
                    // tant pis
                    e.printStackTrace();
                }
        }
        // allow SQLBase to be gc'd even if someone holds on to us
        synchronized (this.baseMutex) {
            this.bases = null;
        }
        super.onDrop();
    }

    private final Object getTreeMutex() {
        final DBSystemRoot sysRoot = this.getDBSystemRoot();
        final Object res = sysRoot == null ? this : sysRoot.getTreeMutex();
        assert Thread.holdsLock(res) || !Thread.holdsLock(this);
        return res;
    }

    Map<String, TablesMap> refresh(final Map<String, TablesMap> namesToRefresh, final boolean readCache) {
        return this.refresh(namesToRefresh, readCache, false);
    }

    // return null if this cannot be refreshed (i.e. this is above DBSystemRoot)
    private Map<String, TablesMap> refresh(final Map<String, TablesMap> tablesToRefresh, final boolean readCache, final boolean init) {
        if (this.getDS() != null) {
            if (Collections.emptyMap().equals(tablesToRefresh))
                return tablesToRefresh;
            final Set<String> namesToRefresh = tablesToRefresh == null ? null : tablesToRefresh.keySet();
            // for mysql we must know our children, since they can reference each other and thus the
            // graph needs them
            final StructureLoadingEvent evt = new StructureLoadingEvent(this, namesToRefresh);
            try {
                this.getDBSystemRoot().fireLoading(evt);
                synchronized (this.getTreeMutex()) {
                    final Set<String> childrenToRefresh = CollectionUtils.inter(namesToRefresh, this.getChildrenNames());
                    // don't save the result in files since getCatalogs() is at least as quick as
                    // executing a request to check if the cache is obsolete
                    final Set<String> allCats;
                    final Connection conn = this.getDS().getNewConnection();
                    try {
                        final List<String> allCatsList = ColumnListHandlerGeneric.create(String.class).handle(conn.getMetaData().getCatalogs());
                        allCats = new HashSet<String>(allCatsList);
                    } finally {
                        this.getDS().returnConnection(conn);
                    }
                    final Set<String> cats = CollectionUtils.inter(namesToRefresh, allCats);
                    this.getDBSystemRoot().filterNodes(this, cats);

                    SQLBase.mustContain(this, cats, childrenToRefresh, "bases");
                    for (final String base : CollectionUtils.substract(childrenToRefresh, cats)) {
                        final CollectionChangeEventCreator c = this.createChildrenCreator();
                        final SQLBase existingBase = this.getBases().remove(base);
                        this.fireChildrenChanged(c);
                        // null if it was never created
                        if (existingBase != null)
                            existingBase.dropped();
                    }
                    // delete the saved bases that we could have fetched, but haven't
                    // (bases that are not in scope are simply ignored, NOT deleted)
                    final DBFileCache cache = this.getFileCache();
                    if (cache != null) {
                        for (final DBItemFileCache savedBase : cache.getServerCache().getSavedDesc(SQLBase.class)) {
                            final String savedBaseName = savedBase.getName();
                            if (!cats.contains(savedBaseName) && (namesToRefresh == null || namesToRefresh.contains(savedBaseName)) && this.getDBSystemRoot().createNode(this, savedBaseName)) {
                                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                                    @Override
                                    public Object run() {
                                        savedBase.delete();
                                        return null;
                                    }
                                });
                            }
                        }
                    }

                    // fire once all the bases are loaded so that the graph is coherent
                    return this.getDBSystemRoot().getGraph().atomicRefresh(new Callable<Map<String, TablesMap>>() {

                        @Override
                        public Map<String, TablesMap> call() throws Exception {
                            final Map<String, TablesMap> res = new HashMap<String, TablesMap>();
                            // add or refresh
                            for (final String cat : cats) {
                                final TablesMap jdbcTables;
                                final SQLBase existing = getBase(cat);
                                if (existing != null) {
                                    jdbcTables = existing.refresh(tablesToRefresh == null ? null : tablesToRefresh.get(cat), readCache);
                                } else {
                                    // ignore tablesToRefresh if the base didn't exist (see
                                    // SQLBase.assureAllTables())
                                    // we already have the datasource, so login/pass aren't used
                                    jdbcTables = createBase(cat, null, "", "", DSINIT_ERROR, readCache);
                                }
                                if (!jdbcTables.isEmpty())
                                    res.put(cat, jdbcTables);
                            }
                            return res;
                        }
                    });
                }
            } catch (SQLException e) {
                throw new IllegalStateException("could not get children names", e);
            } finally {
                this.getDBSystemRoot().fireLoading(evt.createFinishingEvent());
            }
        } else if (!init) {
            throw new IllegalArgumentException("Cannot create bases since this server cannot have a connection");
        }
        return null;
    }

    /**
     * Copy constructor. The new instance is in the same state <code>s</code> was, when it was
     * created (no SQLBase, no default base).
     * 
     * @param s the server to copy from.
     */
    public SQLServer(SQLServer s) {
        this(s.system, s.getName(), null, s.login, s.pass);
    }

    // tries to get a ds without any db
    private synchronized final SQLDataSource getDS() {
        if (!this.dsSet) {
            this.checkDropped();
            final DBSystemRoot sysRoot = this.getDBSystemRoot();
            if (sysRoot == null) {
                this.ds = null;
            } else {
                // should not succeed if pb otherwise with dsSet
                // it will never be called again
                this.ds = sysRoot.getDataSource();
            }
            this.dsSet = true;
        }
        return this.ds;
    }

    final String getURL(String base) {
        return this.urlTransf.transformChecked(base);
    }

    /**
     * Retourne la base par défaut.
     * 
     * @return la base par défaut.
     * @see #setDefaultBase(String)
     */
    public SQLBase getBase() {
        final String def;
        synchronized (this) {
            def = this.defaultBase;
        }
        if (def == null) {
            throw new IllegalStateException("default base unset");
        }
        return this.getBase(def);
    }

    public SQLBase getBase(String baseName) {
        return this.getBases().get(baseName);
    }

    /**
     * Return the specified base using default login/pass.
     * 
     * @param baseName the name of base to be returned.
     * @return the SQLBase named <i>baseName</i>.
     * @see #getBase(String, String, String, IClosure)
     */
    public SQLBase getOrCreateBase(String baseName) {
        return this.getBase(baseName, null, null);
    }

    public SQLBase getBase(String baseName, String login, String pass) {
        return this.getBase(baseName, login, pass, null);
    }

    /**
     * Return the specified base using provided login/pass. Does nothing if there's already a base
     * with this name.
     * 
     * @param baseName the name of the base.
     * @param login the login, <code>null</code> means default.
     * @param pass the password, <code>null</code> means default.
     * @param dsInit to initialize the datasource before any request (eg setting jdbc properties),
     *        <code>null</code> meaning take the server one.
     * @return the corresponding base.
     */
    public SQLBase getBase(String baseName, String login, String pass, IClosure<? super SQLDataSource> dsInit) {
        return this.getBase(baseName, null, login, pass, dsInit, true);
    }

    public SQLBase getBase(String baseName, final IClosure<? super DBSystemRoot> systemRootInit, String login, String pass, IClosure<? super SQLDataSource> dsInit, boolean readCache) {
        if (this.getDBSystemRoot() != null)
            throw new IllegalStateException("getBase(name, login, pass) should only be used for systems where SQLBase is DBSystemRoot");
        synchronized (this.getTreeMutex()) {
            SQLBase base = this.getBase(baseName);
            if (base == null) {
                this.createBase(baseName, systemRootInit, login, pass, dsInit, readCache);
                base = this.getBase(baseName);
            }
            return base;
        }
    }

    private final TablesMap createBase(String baseName, IClosure<? super DBSystemRoot> systemRootInit, String login, String pass, IClosure<? super SQLDataSource> dsInit, boolean readCache) {
        final DBSystemRoot sysRoot = this.getDBSystemRoot();
        if (sysRoot != null && !sysRoot.createNode(this, baseName))
            throw new IllegalStateException(baseName + " is filtered, you must add it to rootsToMap");
        final SQLBase base = new SQLBase(this, baseName, coalesce(systemRootInit, this.systemRootInit), login == null ? this.login : login, pass == null ? this.pass : pass,
                coalesce(dsInit, this.dsInit));
        return this.putBase(baseName, base, readCache);
    }

    public final DBSystemRoot getSystemRoot(String name) {
        return this.getSystemRoot(name, null, null, null, null);
    }

    /**
     * Return the specified systemRoot using provided login/pass. Does nothing if there's already a
     * systemRoot with this name.
     * 
     * @param name name of the system root, NOTE: for some systems the server is the systemRoot so
     *        <code>name</code> will be silently ignored.
     * @param systemRootInit to initialize the {@link DBSystemRoot} before setting the data source.
     * @param login the login, <code>null</code> means default.
     * @param pass the password, <code>null</code> means default.
     * @param dsInit to initialize the datasource before any request (eg setting jdbc properties),
     *        <code>null</code> meaning take the server one.
     * @return the corresponding systemRoot.
     * @see #isSystemRootCreated(String)
     */
    public final DBSystemRoot getSystemRoot(String name, final IClosure<? super DBSystemRoot> systemRootInit, String login, String pass, IClosure<? super SQLDataSource> dsInit) {
        synchronized (this.getTreeMutex()) {
            if (!this.isSystemRootCreated(name)) {
                return this.createSystemRoot(name, systemRootInit, login, pass, dsInit);
            } else {
                final DBSystemRoot res;
                final DBSystemRoot sysRoot = this.getDBSystemRoot();
                if (sysRoot != null)
                    res = sysRoot;
                else {
                    res = this.getBase(name).getDBSystemRoot();
                }
                return res;
            }
        }
    }

    private final DBSystemRoot createSystemRoot(String name, IClosure<? super DBSystemRoot> systemRootInit, String login, String pass, IClosure<? super SQLDataSource> dsInit) {
        final DBSystemRoot res;
        synchronized (this.getTreeMutex()) {
            final DBSystemRoot sysRoot = this.getDBSystemRoot();
            if (sysRoot != null) {
                res = sysRoot;
                res.setDS(coalesce(systemRootInit, this.systemRootInit), login == null ? this.login : login, pass == null ? this.pass : pass, coalesce(dsInit, this.dsInit));
            } else {
                res = this.getBase(name, coalesce(systemRootInit, this.systemRootInit), login, pass, dsInit, true).getDBSystemRoot();
            }
        }
        return res;
    }

    /**
     * Whether the system root is created and has a datasource.
     * 
     * @param name the system root name.
     * @return <code>true</code> if the system root has a datasource.
     */
    public final boolean isSystemRootCreated(String name) {
        synchronized (this.getTreeMutex()) {
            final DBSystemRoot sysRoot = this.getDBSystemRoot();
            if (sysRoot != null)
                return sysRoot.hasDataSource();
            else
                return this.isCreated(name) && this.getBase(name).getDBSystemRoot().hasDataSource();
        }
    }

    private TablesMap putBase(String baseName, SQLBase base, boolean readCache) {
        assert Thread.holdsLock(getTreeMutex());
        final CollectionChangeEventCreator c = this.createChildrenCreator();
        this.getBases().put(baseName, base);
        final TablesMap res = base.init(readCache);
        this.fireChildrenChanged(c);
        // if base is null, no new tables (furthermore descendantsChanged() would create our
        // children)
        if (base != null)
            if (this.getDBSystemRoot() != null)
                this.getDBSystemRoot().descendantsChanged(this, Collections.singleton(baseName), readCache);
        // defaultBase must be null, otherwise the user has already expressed his choice
        synchronized (this) {
            final boolean setDef = this.defaultBase == null && base != null;
            if (setDef) {
                this.setDefaultBase(baseName);
            }
        }
        return res;
    }

    @Override
    public Map<String, SQLBase> getChildrenMap() {
        return this.getBases().getImmutable();
    }

    /**
     * Has the passed base already been created. Useful as when this returns <code>true</code>,
     * {@link #getBase(String, String, String, IClosure)} won't do anything but return the already
     * created base, in particular the closure won't be used.
     * 
     * @param baseName the name of the base.
     * @return <code>true</code> if an instance of SQLBase already exists.
     */
    public boolean isCreated(String baseName) {
        return this.getBase(baseName) != null;
    }

    /**
     * Met la base par défaut. Note: la première base ajoutée devient automatiquement la base par
     * défaut.
     * 
     * @param defaultBase le nom de la base par défaut, can be <code>null</code>.
     * @see #getBase()
     */
    public void setDefaultBase(String defaultBase) {
        synchronized (this.getTreeMutex()) {
            if (defaultBase != null && !this.contains(defaultBase))
                throw new IllegalArgumentException(defaultBase + " unknown");
            synchronized (this) {
                this.defaultBase = defaultBase;
            }
        }
    }

    public String toString() {
        return this.getName();
    }

    /**
     * Return the name of the system of this server.
     * 
     * @return the name of the system.
     * @deprecated use {@link #getSQLSystem()}
     */
    public final String getSystem() {
        return this.getSQLSystem().getJDBCName();
    }

    public final SQLSystem getSQLSystem() {
        return this.system;
    }

    public final synchronized void setID(final String id) {
        this.id = id;
    }

    // needed since the host doesn't always identify one server (e.g. 127.0.0.1:1234 might be a
    // tunnel to different servers)
    public final synchronized String getID() {
        return this.id;
    }

    public final DBFileCache getFileCache() {
        return DBFileCache.create(this);
    }

    /**
     * The host name of this server.
     * 
     * @return the host name, <code>null</code> if not accessed through network.
     */
    public final String getHostname() {
        return this.getHostnameAndPath().get0();
    }

    public final List2<String> getHostnameAndPath() {
        return this.getSQLSystem().getHostnameAndPath(this.getName());
    }

    public final boolean isPermanent() {
        return this.getSQLSystem().isPermanent(this.getName());
    }

    /**
     * Whether this server runs on the local machine.
     * 
     * @return <code>true</code> if the JVM runs on the same machine than <code>this</code>.
     */
    protected final boolean isLocalhost() {
        // this method cannot be in SQLSyntax since it is used in the constructor of SQLDataSource
        // (which is needed by SQLSyntax.create())

        final String host = this.getHostname();
        if (host == null)
            return true;
        final int colonIndex = host.indexOf(':');
        final String hostWOPort = colonIndex < 0 ? host : host.substring(0, colonIndex);
        return NetUtils.isSelfAddr(hostWOPort);
    }

    public final boolean isPersistent() {
        return this.getSQLSystem() != SQLSystem.H2 || !this.getName().equals(SQLSystem.H2_IN_MEMORY);
    }
}