ConnectionManager.cs :  » Business-Application » DC » DCSharp » Backend » Managers » C# / CSharp Open Source

/* 
 * Copyright (C) 2004-2005 Jonathan Bindel
 * Copyright (C) 2006-2007 Eskil Bylund
 *
 * 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

using System;
using System.Collections;
using System.Collections.Generic;
using System.Timers;

using DCSharp.Backend.Connections;
using DCSharp.Backend.Objects;

namespace DCSharp.Backend.Managers{
  public delegate void ConnectionRequestHandler(HubConnection hub, User user);
  
  public class ConnectionManager : IEnumerable<UserConnection>
  {
    public event EventHandler<ConnectionEventArgs> ConnectionAdded;
    public event EventHandler<ConnectionEventArgs> ConnectionRemoved;

    private const int TimerInterval = 10000;
    private const int BusyLength = 2 * 60 * 1000;
    
    private HubManager hubManager;
    
    private List<UserConnection> connections;
    private List<User> pendingConnections;
    private List<User> busyConnections;

    public ConnectionManager(HubManager hubManager)
    {
      if (hubManager == null)
      {
        throw new ArgumentNullException("hubManager");
      }
      this.hubManager = hubManager;
      
      connections = new List<UserConnection>();
      pendingConnections = new List<User>();
      busyConnections = new List<User>();
    }

    #region Properties

    public int Count
    {
      get { return connections.Count; }
    }
    
    public object SyncRoot
    {
      get { return connections; }
    }
    
    #endregion

    #region Methods

    public void Add(UserConnection connection)
    {
      if (connection == null)
      {
        throw new ArgumentNullException("connection");
      }
      if (connection.RemoteIdentity == null)
      {  
        throw new ArgumentException("The connection has remote user identity.");
      }
      
      lock (connections)
      {
        if (!connections.Contains(connection))
        {
          connections.Add(connection);
          pendingConnections.Remove(connection.RemoteIdentity.User);
          
          OnConnectionAdded(connection);
        }
      }
    }

    public void Remove(UserConnection connection)
    {
      if (connection == null)
      {
        throw new ArgumentNullException("connection");
      }
      
      lock (connections)
      {
        if (connections.Contains(connection))
        {
          connections.Remove(connection);
          OnConnectionRemoved(connection);
        }
      }
    }

    public bool Contains(UserConnection connection)
    {
      return connections.Contains(connection);
    }
    
    public IEnumerator<UserConnection> GetEnumerator()
    {
      return connections.GetEnumerator();
    }
    
    IEnumerator IEnumerable.GetEnumerator()
    {
      return GetEnumerator();
    }
    
    #region Connection request
    
    public bool CanRequest(User user)
    {
      if (pendingConnections.Contains(user) ||
        busyConnections.Contains(user))
      {
        return false;
      }
      return true;
    }
    
    public void HoldConnection(User user)
    {
      busyConnections.Add(user);
      
      Timer timer = new Timer();
      timer.Interval = BusyLength;
      timer.Elapsed += delegate
      {
        busyConnections.Remove(user);
        timer.Stop();
        
        // TODO: Add CanRequest event and update the downloader.
      };
      timer.Start();
    }
    
    public bool UserIsBusy(User user)
    {
      return busyConnections.Contains(user);
    }
    
    public bool IsRequestingConnectionTo(User user)
    {
      return pendingConnections.Contains(user);
    }
    
    public bool RequestConnection(User user,
      ConnectionRequestHandler failedCallback)
    {
      HubConnection hub = hubManager.GetHubWithUser(user);
      if (hub != null)
      {
        return RequestConnection(hub, user, failedCallback);
      }
      return false;
    }
    
    public bool RequestConnection(HubConnection hub, User user,
      ConnectionRequestHandler failedCallback)
    {
      if (hub == null)
      {
        throw new ArgumentNullException("hub");
      }
      if (user == null)
      {
        throw new ArgumentNullException("user");
      }
      
      Identity identity = hub.Users[user];
      
      if (pendingConnections.Contains(user) || user == null)
      {
        return false;
      }
      
      hub.RequestConnection(identity);
      pendingConnections.Add(user);
      
      Timer timer = new Timer(TimerInterval);
      timer.Elapsed += delegate
      {
        if (pendingConnections.Contains(user))
        {
          pendingConnections.Remove(user);
          if (failedCallback != null)
          {
            failedCallback(hub, user);
          }
        }
        timer.Stop();
      };
      timer.Start();
      return true;
    }

    #endregion

    protected virtual void OnConnectionAdded(UserConnection connection)
    {
      if (ConnectionAdded != null)
      {
        ConnectionAdded(this, new ConnectionEventArgs(connection));
      }
    }
    
    protected virtual void OnConnectionRemoved(UserConnection connection)
    {
      if (ConnectionRemoved != null)
      {
        ConnectionRemoved(this, new ConnectionEventArgs(connection));
      }
    }

    #endregion
  }
}