using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;
namespace MethodWorx.AspNetComet.Core
{
/// <summary>
/// CometMessage Class
///
/// This is a CometMessage that has been sent to the client, the DataContract names have been
/// shortened to remove any bytes we dont need from the message (ok, did'nt save much, but we can do it!)
/// </summary>
[DataContract(Name="cm")]
public class CometMessage
{
[DataMember(Name="mid")]
private long messageId;
[DataMember(Name="n")]
private string name;
[DataMember(Name="c")]
private object contents;
/// <summary>
/// Gets or Sets the MessageId, used to track which message the Client last received
/// </summary>
public long MessageId
{
get { return this.messageId; }
set { this.messageId = value; }
}
/// <summary>
/// Gets or Sets the Content of the Message
/// </summary>
public object Contents
{
get { return this.contents; }
set { this.contents = value; }
}
/// <summary>
/// Gets or Sets the error message if this is a failure
/// </summary>
public string Name
{
get { return this.name; }
set { this.name = value; }
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;
namespace MethodWorx.AspNetComet.Core
{
/// <summary>
/// CometClient Class
///
/// This represents a logged in client within the COMET application. This marked as a DataContract becuase
/// it can be seralized to the client using JSON
/// </summary>
[DataContract]
public class CometClient
{
[DataMember]
private string privateToken;
[DataMember]
private string publicToken;
[DataMember]
private string displayName;
[DataMember]
private DateTime lastActivity;
[DataMember]
private int connectionIdleSeconds;
[DataMember]
private int connectionTimeoutSeconds;
/// <summary>
/// Gets or Sets the token used to identify the client to themselves
/// </summary>
public string PrivateToken
{
get { return this.privateToken; }
set { this.privateToken = value; }
}
/// <summary>
/// Gets or Sets the token used to identify the client to other clients
/// </summary>
public string PublicToken
{
get { return this.publicToken; }
set { this.publicToken = value; }
}
/// <summary>
/// Gets or Sets the display name of the client
/// </summary>
public string DisplayName
{
get { return this.displayName; }
set { this.displayName = value; }
}
/// <summary>
/// Gets or Sets the last activity of the client
/// </summary>
public DateTime LastActivity
{
get { return this.lastActivity; }
set { this.lastActivity = value; }
}
/// <summary>
/// Gets or Sets the ConnectionIdleSections property which is the number of seconds a connection will remain
/// alive for without being connected to a client, after this time has expired the client will
/// be removed from the state manager
/// </summary>
public int ConnectionIdleSeconds
{
get { return this.connectionIdleSeconds; }
set { this.connectionIdleSeconds = value; }
}
/// <summary>
/// Gets or Sets the ConnectionTimeOutSections property which is the number of seconds a connection will remain
/// alive for whilst being connected to a client, but without receiving any messages. After a timeout has expired
/// A client should restablish a connection to the server
/// </summary>
public int ConnectionTimeoutSeconds
{
get { return this.connectionTimeoutSeconds; }
set { this.connectionTimeoutSeconds = value; }
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace MethodWorx.AspNetComet.Core
{
/// <summary>
/// This interface can be implemented to provide a custom state provider
/// for the CometStateManager class. Typical examples may be using SqlServer
/// to enable the operation over a server farm
/// </summary>
public interface ICometStateProvider
{
/// <summary>
/// Implementation of this method should store the cometClient instance in some sort
/// of cache (eg Memory, Db etc..)
/// </summary>
/// <param name="cometClient"></param>
void InitializeClient(CometClient cometClient);
/// <summary>
/// Imeplementation of this method should return all the messages that are queued
/// for a specific client, it is only interested in messages that have a greater id than
/// lastMessageId
/// </summary>
/// <param name="clientPrivateToken"></param>
/// <param name="lastMessageId"></param>
/// <returns></returns>
CometMessage[] GetMessages(string clientPrivateToken, long lastMessageId);
/// <summary>
/// Implementation of this method should queue a message for the specific client
/// </summary>
/// <param name="clientPublicToken"></param>
/// <param name="name"></param>
/// <param name="contents"></param>
void SendMessage(string clientPublicToken, string name, object contents);
/// <summary>
/// Implementation of this method should queue a message for all the clients
/// </summary>
/// <param name="name"></param>
/// <param name="contents"></param>
void SendMessage(string name, object contents);
/// <summary>
/// Implementation of this method should return a specific comet client
/// </summary>
/// <param name="clientPrivateToken"></param>
/// <returns></returns>
CometClient GetCometClient(string clientPrivateToken);
/// <summary>
/// Implementation of this method should remove a client from the cache
/// </summary>
/// <param name="clientPrivateToken"></param>
void KillIdleCometClient(string clientPrivateToken);
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace MethodWorx.AspNetComet.Core
{
/// <summary>
/// Class InProcCometStateProvider
///
/// This class provides an implementation of ICometStateProvider that keeps the
/// information in memory. This provider is not scalable as it will not run on a server
/// farm but demonstrates how you should implemement the provider.
/// </summary>
public class InProcCometStateProvider : ICometStateProvider
{
/// <summary>
/// Private class which holds the state of each connected client
/// </summary>
private class InProcCometClient
{
public CometClient CometClient;
public Dictionary<long, CometMessage> Messages = new Dictionary<long, CometMessage>();
public long NextMessageId = 1;
}
/// <summary>
/// Cache of clients
/// </summary>
private Dictionary<string, InProcCometClient> publicClients = new Dictionary<string, InProcCometClient>();
private Dictionary<string, InProcCometClient> privateClients = new Dictionary<string, InProcCometClient>();
private static object state = new object();
#region ICometStateProvider Members
/// <summary>
/// Store the new client in memory
/// </summary>
/// <param name="cometClient"></param>
public void InitializeClient(CometClient cometClient)
{
if (cometClient == null)
throw new ArgumentNullException("cometClient");
lock (state)
{
// ok, ensure we dont already exist
if (publicClients.ContainsKey(cometClient.PublicToken) || privateClients.ContainsKey(cometClient.PrivateToken))
throw CometException.CometClientAlreadyExistsException();
InProcCometClient inProcCometClient = new InProcCometClient()
{
CometClient = cometClient
};
// stick the client int he arrays
// ready to be used
publicClients.Add(cometClient.PublicToken, inProcCometClient);
privateClients.Add(cometClient.PrivateToken, inProcCometClient);
}
// ok, they are in there ready to be used
}
/// <summary>
/// Get the messages for a specific client
/// </summary>
/// <param name="clientPrivateToken"></param>
/// <param name="lastMessageId"></param>
/// <returns></returns>
public CometMessage[] GetMessages(string clientPrivateToken, long lastMessageId)
{
if(string.IsNullOrEmpty(clientPrivateToken))
throw new ArgumentNullException("clientPrivateToken");
lock (state)
{
if (!privateClients.ContainsKey(clientPrivateToken))
throw CometException.CometClientDoesNotExistException();
//
// ok, get the client
InProcCometClient cometClient = privateClients[clientPrivateToken];
List<long> toDelete = new List<long>();
List<long> toReturn = new List<long>();
// wicked, we have the client, so we can get its messages from our list
// we delete any before the last messageId becuase we dont want them
foreach(long key in cometClient.Messages.Keys)
{
if(key <= lastMessageId)
toDelete.Add(key);
else
toReturn.Add(key);
}
// delete the ones from the messages
foreach (long key in toDelete)
{
cometClient.Messages.Remove(key);
}
// and return the ones in the toReturn array
List<CometMessage> cometMessages = new List<CometMessage>();
foreach (long key in toReturn)
{
cometMessages.Add(cometClient.Messages[key]);
}
return cometMessages.ToArray();
}
}
/// <summary>
/// Send a message to a specific client
/// </summary>
/// <param name="clientPublicToken"></param>
/// <param name="name"></param>
/// <param name="contents"></param>
public void SendMessage(string clientPublicToken, string name, object contents)
{
if (string.IsNullOrEmpty(clientPublicToken))
throw new ArgumentNullException("clientPublicToken");
if (contents == null)
throw new ArgumentNullException("contents");
lock (state)
{
if (!publicClients.ContainsKey(clientPublicToken))
throw CometException.CometClientDoesNotExistException();
//
// ok, get the client
InProcCometClient cometClient = publicClients[clientPublicToken];
// ok, stick the message in the array
CometMessage message = new CometMessage();
message.Contents = contents;
message.Name = name;
message.MessageId = cometClient.NextMessageId;
// increment
cometClient.NextMessageId++;
cometClient.Messages.Add(message.MessageId, message);
}
}
/// <summary>
/// Send a message to all the clients
/// </summary>
/// <param name="name"></param>
/// <param name="contents"></param>
public void SendMessage(string name, object contents)
{
if (contents == null)
throw new ArgumentNullException("contents");
lock (state)
{
foreach (InProcCometClient cometClient in publicClients.Values)
{
// ok, stick the message in the array
CometMessage message = new CometMessage();
message.Contents = contents;
message.Name = name;
message.MessageId = cometClient.NextMessageId;
// increment
cometClient.NextMessageId++;
cometClient.Messages.Add(message.MessageId, message);
}
}
}
/// <summary>
/// Get the client from the state provider
/// </summary>
/// <param name="clientPrivateToken"></param>
/// <returns></returns>
public CometClient GetCometClient(string clientPrivateToken)
{
if (!this.privateClients.ContainsKey(clientPrivateToken))
throw CometException.CometClientDoesNotExistException();
// return the client private token
return this.privateClients[clientPrivateToken].CometClient;
}
/// <summary>
/// Remove an idle client from the memory
/// </summary>
/// <param name="clientPrivateToken"></param>
public void KillIdleCometClient(string clientPrivateToken)
{
if (!this.privateClients.ContainsKey(clientPrivateToken))
throw CometException.CometClientDoesNotExistException();
// get the client
InProcCometClient ipCometClient = this.privateClients[clientPrivateToken];
// and remove the dictionarys
this.privateClients.Remove(ipCometClient.CometClient.PrivateToken);
this.publicClients.Remove(ipCometClient.CometClient.PublicToken);
}
#endregion
}
}
