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.

 */

 package org.openconcerto.sql.users;

import org.openconcerto.sql.model.SQLRow;

import org.openconcerto.sql.model.SQLRowValues;

import org.openconcerto.sql.model.SQLRowValuesListFetcher;

import org.openconcerto.sql.model.SQLTable;

import org.openconcerto.sql.model.SQLTableEvent;

import org.openconcerto.sql.model.SQLTableModifiedListener;

import org.openconcerto.utils.CompareUtils;

import org.openconcerto.utils.ThreadFactory;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.util.ArrayList;

import java.util.Collections;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.concurrent.Callable;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.ScheduledFuture;

import java.util.concurrent.TimeUnit;

import net.jcip.annotations.GuardedBy;

import net.jcip.annotations.ThreadSafe;

@ThreadSafe

public class UserManager implements UserSingleton {

    public static enum State {

        CREATED, VALID, DESTROYED

    }

    private static final UserSingletonManager<UserManager> sMngr = new UserSingletonManager<UserManager>("USER_COMMON") {

        @Override

        protected UserManager createInstance(SQLTable t) {

            return new UserManager(t).start();

        }

    };

    public static UserSingletonManager<UserManager> getSingletonManager() {

        return sMngr;

    }

    public static UserManager setInstance(final SQLTable t) {

        return getSingletonManager().setInstance(t);

    }

    public static final UserManager getInstance() {

        return getSingletonManager().getInstance();

    }

    public static final User getUser() {

        final UserManager mngr = getInstance();

        return getCurrentUser(mngr);

    }

    public static User getCurrentUser(final UserManager mngr) {

        return mngr == null ? null : mngr.getCurrentUser();

    }

    public static final int getUserID() {

        final User user = getUser();

        return user == null ? SQLRow.NONEXISTANT_ID : user.getId();

    }

    // maximum age of DB data

    private static final long MAX_AGE_MS = 8 * 60 * 1000;

    public static final String CURRENT_USERID_PROPNAME = "currentUserID";

    public static final String USERS_PROPNAME = "users";

    private final SQLTable t;

    @GuardedBy("this")

    private Map<Integer, User> byID;

    @GuardedBy("this")

    private long timeOfLastFill = -1;

    // don't store User because of refresh()

    @GuardedBy("this")

    private Integer currentUserID;

    private final SQLTableModifiedListener tableL;

    @GuardedBy("this")

    private ScheduledFuture<?> scheduledUpdateUsers;

    @GuardedBy("this")

    private Future<?> updateUsers;

    // a user call has placed a runnable to be executed, don't cancel previously added refresh

    @GuardedBy("this")

    private Future<?> userFuture;

    private final ScheduledExecutorService exec;

    private final PropertyChangeSupport supp = new PropertyChangeSupport(this);

    public UserManager(final SQLTable t) {

        this.byID = null;

        this.currentUserID = null;

        this.t = t;

        this.exec = Executors.newScheduledThreadPool(1, new ThreadFactory(UserManager.class.getSimpleName() + " executor for " + t.getSQLName(), true).setPriority(Thread.MIN_PRIORITY));

        this.tableL = new SQLTableModifiedListener() {

            @Override

            public void tableModified(SQLTableEvent evt) {

                refresh(true);

            }

        };

    }

    public final UserManager start() {

        return this.start(MAX_AGE_MS);

    }

    public final synchronized UserManager start(final long maxAge) {

        if (this.getState() != State.CREATED)

            throw new IllegalStateException("Already started");

        this.t.addTableModifiedListener(this.tableL);

        fillUsers();

        this.scheduledUpdateUsers = this.exec.scheduleWithFixedDelay(new Runnable() {

            @Override

            public void run() {

                refreshIfNeeded(maxAge);

            }

        }, maxAge / 4, maxAge / 4, TimeUnit.MILLISECONDS);

        return this;

    }

    public final boolean isValid() {

        return getState() == State.VALID;

    }

    public synchronized final State getState() {

        if (this.scheduledUpdateUsers == null)

            return State.CREATED;

        else if (this.scheduledUpdateUsers.isDone())

            return State.DESTROYED;

        else

            return State.VALID;

    }

    @Override

    public synchronized final void destroy() {

        final State s = this.getState();

        if(s == State.DESTROYED)

            return;

        if (s == State.VALID) {

            this.getTable().removeTableModifiedListener(this.tableL);

            this.scheduledUpdateUsers.cancel(true);

            this.cancelUpdate();

        }

        this.exec.shutdown();

        assert this.getState() == State.DESTROYED;

    }

    private void cancelUpdate() {

        assert Thread.holdsLock(this);

        if (this.updateUsers != null && (this.userFuture == null || this.userFuture.isDone()))

            this.updateUsers.cancel(true);

    }

    private boolean isUpdatePending() {

        assert Thread.holdsLock(this);

        return this.updateUsers != null && !this.updateUsers.isDone();

    }

    private synchronized void refreshIfNeeded(final long maxAge) {

        final long dataAge = System.currentTimeMillis() - this.timeOfLastFill;

        // refresh if the data is old enough and no update is pending

        if (dataAge > maxAge && !this.isUpdatePending())

            refresh(true);

    }

    public void refresh() {

        if (!this.isValid())

            throw new IllegalStateException("No longer valid");

        this.refresh(false);

    }

    // don't return the future as it might be canceled despite the fact that a subsequent

    // invokeLater() might need it

    private synchronized void refresh(final boolean thisClass) {

        cancelUpdate();

        this.updateUsers = invokeLater(new Callable<Object>() {

            @Override

            public Object call() throws Exception {

                // allow multiple close refresh to be cancelled by the last one

                if (thisClass)

                    Thread.sleep(30);

                fillUsers();

                return null;

            }

        }, false);

        // the new updateUsers is after userFuture, so we can cancel it

        this.userFuture = null;

    }

    public final <T> Future<T> invokeLater(final Callable<T> c) {

        return this.invokeLater(c, true);

    }

    public synchronized final <T> Future<T> invokeLater(final Callable<T> c, final boolean needsPreviousUpdate) {

        if (!this.isValid())

            return null;

        final Future<T> res = this.exec.submit(c);

        if (needsPreviousUpdate) {

            this.userFuture = res;

        }

        return res;

    }

    private void fillUsers() {

        // to keep the ORDER for #getAllUser()

        final Map<Integer, User> mutable = new LinkedHashMap<Integer, User>();

        final SQLRowValuesListFetcher fetcher = new SQLRowValuesListFetcher(new SQLRowValues(this.t).setAllToNull());

        fetcher.setOrdered(true);

        for (final SQLRowValues v : fetcher.fetch()) {

            final User u = new User(v);

            mutable.put(v.getID(), u);

        }

        final Map<Integer, User> immutable = Collections.unmodifiableMap(mutable);

        final Map<Integer, User> old;

        synchronized (this) {

            old = this.byID;

            this.byID = immutable;

            this.timeOfLastFill = System.currentTimeMillis();

        }

        this.supp.firePropertyChange(USERS_PROPNAME, old, immutable);

    }

    @Override

    public final SQLTable getTable() {

        return this.t;

    }

    /**

     * All users indexed by their IDs.

     *

     * @return all users.

     */

    public synchronized final Map<Integer, User> getUsers() {

        if (this.byID == null)

            throw new IllegalStateException(this + " wasn't started successfully");

        return this.byID;

    }

    public final void addUsersListener(final PropertyChangeListener l) {

        this.supp.addPropertyChangeListener(USERS_PROPNAME, l);

    }

    public final void removeUsersListener(final PropertyChangeListener l) {

        this.supp.removePropertyChangeListener(USERS_PROPNAME, l);

    }

    public synchronized final User getCurrentUser() {

        return this.currentUserID == null ? null : this.getUser(this.currentUserID);

    }

    public synchronized final Integer getCurrentUserID() {

        return this.currentUserID;

    }

    @Deprecated

    public void setCurrentUser(final Number id) {

        this.setCurrentUserID(id);

    }

    public void setCurrentUserID(final Number id) {

        final Integer newVal = id == null || id instanceof Integer ? (Integer) id : Integer.valueOf(id.intValue());

        final boolean modified;

        synchronized (this) {

            modified = !CompareUtils.equals(this.currentUserID, newVal);

            if (modified)

                this.currentUserID = newVal;

        }

        if (modified)

            this.supp.firePropertyChange(CURRENT_USERID_PROPNAME, null, newVal);

    }

    public final void addCurrentUserIDListener(final PropertyChangeListener l) {

        this.supp.addPropertyChangeListener(CURRENT_USERID_PROPNAME, l);

    }

    public final void removeCurrentUserIDListener(final PropertyChangeListener l) {

        this.supp.removePropertyChangeListener(CURRENT_USERID_PROPNAME, l);

    }

    public List<User> getAllActiveUsers() {

        final List<User> result = new ArrayList<User>();

        for (User user : this.getUsers().values()) {

            if (user.isActive()) {

                result.add(user);

            }

        }

        return result;

    }

    public User getUser(final Integer v) {

        final Map<Integer, User> users = this.getUsers();

        if (users.containsKey(v))

            return users.get(v);

        else

            throw new IllegalStateException("Bad user! " + v);

    }

}