ConnectionMonitor.java

// **********************************************************************
//
// Copyright (c) 2003-2010 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

package IceInternal;

public final class ConnectionMonitor implements IceInternal.TimerTask
{
    //
    // Renamed from destroy to _destroy to avoid a deprecation warning caused
    // by the destroy method inherited from Thread.
    //
    synchronized public void
    destroy()
    {
        assert(_instance != null);
        _instance = null;
        _connections = null;
    }

    public void
    checkIntervalForACM(int acmTimeout)
    {
        if(acmTimeout <= 0)
        {
            return;
        }

        //
        // If Ice.MonitorConnections isn't set (_interval == 0), the given ACM is used
        // to determine the check interval: 1/10 of the ACM timeout with a minmal value
        // of 5 seconds and a maximum value of 5 minutes.
        //
        // Note: if Ice.MonitorConnections is set, the timer is schedulded only if ACM 
        // is configured for the communicator or some object adapters.
        //
        int interval;
        if(_interval == 0)
        {
            interval = java.lang.Math.min(300, java.lang.Math.max(5, (int)acmTimeout / 10));
        }
        else if(_scheduledInterval == _interval)
        {
            return; // Nothing to do, the timer is already scheduled.
        }
        else
        {
            interval = _interval;
        }

        //
        // If no timer is scheduled yet or if the given ACM requires a smaller interval,
        // we re-schedule the timer.
        //
        synchronized(this)
        {
            if(_scheduledInterval == 0 || _scheduledInterval > interval)
            {
                _scheduledInterval = interval;
                _instance.timer().cancel(this);
                _instance.timer().scheduleRepeated(this, interval * 1000);
            }
        }
    }
        
    public synchronized void
    add(Ice.ConnectionI connection)
    {
        assert(_instance != null);
        _connections.add(connection);
    }
    
    public synchronized void
    remove(Ice.ConnectionI connection)
    {
        assert(_instance != null);
        _connections.remove(connection);
    }

    //
    // Only for use by Instance.
    //
    ConnectionMonitor(Instance instance, int interval)
    {
        _instance = instance;
        _interval = interval;
        _scheduledInterval = 0;
    }

    protected synchronized void
    finalize()
        throws Throwable
    {
        IceUtilInternal.Assert.FinalizerAssert(_instance == null);
        IceUtilInternal.Assert.FinalizerAssert(_connections == null);
        
        super.finalize();
    }

    public void
    runTimerTask()
    {
        java.util.Set<Ice.ConnectionI> connections = new java.util.HashSet<Ice.ConnectionI>();

        synchronized(this)
        {
            if(_instance == null)
            {
                return;
            }
            
            connections.clear();
            connections.addAll(_connections);
        }
        
        //
        // Monitor connections outside the thread synchronization,
        // so that connections can be added or removed during
        // monitoring.
        //
        long now = IceInternal.Time.currentMonotonicTimeMillis();
        for(Ice.ConnectionI conn : connections)
        {
            try
            {              
                conn.monitor(now);
            }
            catch(java.lang.Exception ex)
            {
                synchronized(this)
                {
                    if(_instance == null)
                    {
                        return;
                    }
                    String s = "exception in connection monitor:\n" + Ex.toString(ex);
                    _instance.initializationData().logger.error(s);
                }
            }
        }
    }
    
    private Instance _instance;
    private final int _interval;
    private int _scheduledInterval;
    private java.util.Set<Ice.ConnectionI> _connections = new java.util.HashSet<Ice.ConnectionI>();
}