/// <summary>
/// Connects to a remote shared object on the server through the specified connection. Use this method after
/// issuing SharedObject.GetRemote(...). After a successful connection, the sync event is dispatched.
/// </summary>
/// <param name="connection">A NetConnection object (such as one used to communicate with Flash Media Server) that is using the Real-Time Messaging Protocol (RTMP).</param>
/// <param name="parameters">Parameters.</param>
public void Connect(NetConnection connection, string parameters)
{
if (_initialSyncReceived)
{
throw new InvalidOperationException("SharedObject already connected");
}
ValidationUtils.ArgumentNotNull(connection, "connection");
ValidationUtils.ArgumentNotNull(connection.Uri, "connection");
ValidationUtils.ArgumentConditionTrue(connection.Uri.Scheme == "rtmp", "connection", "NetConnection object must use the Real-Time Messaging Protocol (RTMP)");
ValidationUtils.ArgumentConditionTrue(connection.Connected, "connection", "NetConnection object must be connected");
_connection = connection;
_initialSyncReceived = false;
dotFlex.Messaging.Rtmp.SO.SharedObjectMessage message;
if (connection.ObjectEncoding == ObjectEncoding.AMF0)
{
message = new dotFlex.Messaging.Rtmp.SO.SharedObjectMessage(_name, _version, _persistentSO);
}
else
{
message = new dotFlex.Messaging.Rtmp.SO.FlexSharedObjectMessage(_name, _version, _persistentSO);
}
dotFlex.Messaging.Rtmp.SO.SharedObjectEvent evt = new dotFlex.Messaging.Rtmp.SO.SharedObjectEvent(dotFlex.Messaging.Rtmp.SO.SharedObjectEventType.SERVER_CONNECT, null, null);
message.AddEvent(evt);
_connection.NetConnectionClient.Write(message);
}
/// <summary>
/// Initializes a new instance of the SharedObject class.
/// </summary>
/// <param name="data"></param>
/// <param name="name"></param>
/// <param name="path"></param>
/// <param name="persistent"></param>
public SharedObject(IDictionary data, string name, string path, bool persistent)
{
base.SetAttributes(data);
_name = name;
_path = path;
_persistentSO = persistent;
_ownerMessage = new SharedObjectMessage(null, name, 0, persistent);
_creationTime = System.Environment.TickCount;
}
/// <summary>
/// Closes the connection between a remote shared object and the server.
/// </summary>
public void Close()
{
if (_initialSyncReceived && _connection != null && _connection.Connected)
{
dotFlex.Messaging.Rtmp.SO.SharedObjectMessage message;
if (_connection.ObjectEncoding == ObjectEncoding.AMF0)
{
message = new dotFlex.Messaging.Rtmp.SO.SharedObjectMessage(_name, _version, _persistentSO);
}
else
{
message = new dotFlex.Messaging.Rtmp.SO.FlexSharedObjectMessage(_name, _version, _persistentSO);
}
dotFlex.Messaging.Rtmp.SO.SharedObjectEvent evt = new dotFlex.Messaging.Rtmp.SO.SharedObjectEvent(dotFlex.Messaging.Rtmp.SO.SharedObjectEventType.SERVER_DISCONNECT, null, null);
message.AddEvent(evt);
_connection.NetConnectionClient.Write(message);
// clear collections
base.RemoveAttributes();
_ownerMessage.Events.Clear();
}
_initialSyncReceived = false;
}
/// <summary>
/// Send update notification over data channel of RTMP connection
/// </summary>
private void SendUpdates()
{
int currentVersion = _version.Value;
bool persist = this.IsPersistentObject;
//Get read-only version of events
ConcurrentLinkedQueue<ISharedObjectEvent> events = new ConcurrentLinkedQueue<ISharedObjectEvent>(_ownerMessage.Events);
//clear out previous events
_ownerMessage.Events.Clear();
if (events.Count != 0)
{
//Send update to "owner" of this update request
if(_source != null)
{
RtmpConnection connection = _source as RtmpConnection;
// Only send updates when issued through RTMP request
RtmpChannel channel = connection.GetChannel((byte)3);
// Send update to "owner" of this update request
SharedObjectMessage syncOwner;
if (connection.ObjectEncoding == ObjectEncoding.AMF0)
syncOwner = new SharedObjectMessage(null, _name, currentVersion, persist);
else
syncOwner = new FlexSharedObjectMessage(null, _name, currentVersion, persist);
syncOwner.AddEvents(events);
if(channel != null)
{
channel.Write(syncOwner);
}
else
{
log.Warn(__Res.GetString(__Res.Channel_NotFound));
}
}
}
//Clear owner events
events.Clear();
//Get read-only version of sync events
events.AddRange(_syncEvents);
//Clear out previous events
_syncEvents.Clear();
if (events.Count != 0)
{
// Synchronize updates with all registered clients of this shared
foreach(IEventListener listener in _listeners)
{
if(listener == _source)
{
// Don't re-send update to active client
continue;
}
if(!(listener is RtmpConnection))
{
log.Warn(__Res.GetString(__Res.SharedObject_SyncConnError));
continue;
}
// Create a new sync message for every client to avoid
// concurrent access through multiple threads
// TODO: perhaps we could cache the generated message
RtmpConnection connection = listener as RtmpConnection;
SharedObjectMessage syncMessage;
if (connection.ObjectEncoding == ObjectEncoding.AMF0)
syncMessage = new SharedObjectMessage(null, _name, currentVersion, persist);
else
syncMessage = new FlexSharedObjectMessage(null, _name, currentVersion, persist);
syncMessage.AddEvents(events);
RtmpChannel channel = connection.GetChannel((byte)3);
log.Debug(__Res.GetString(__Res.SharedObject_Sync, channel));
channel.Write(syncMessage);
}
}
}
/// <summary>
/// Initializes a new instance of the SharedObject class.
/// </summary>
/// <param name="data"></param>
/// <param name="name"></param>
/// <param name="path"></param>
/// <param name="persistent"></param>
public SharedObject(IDictionary data, string name, string path, bool persistent)
{
base.SetAttributes(data);
_name = name;
_path = path;
_persistentSO = persistent;
_ownerMessage = new SharedObjectMessage(null, name, 0, persistent);
_creationTime = System.Environment.TickCount;
}
/// <summary>
/// Initializes a new instance of the SharedObject class. This is used by the persistence framework.
/// </summary>
public SharedObject()
{
_ownerMessage = new SharedObjectMessage(null, null, -1, false);
_persistentSO = false;
_creationTime = System.Environment.TickCount;
}
static ISharedObjectMessage DecodeSharedObject(ByteBuffer stream)
{
RtmpReader reader = new RtmpReader(stream);
string name = reader.ReadString();
// Read version of SO to modify
int version = reader.ReadInt32();
// Read persistence informations
bool persistent = reader.ReadInt32() == 2;
// Skip unknown bytes
//skip(4);
reader.ReadInt32();
SharedObjectMessage so = new SharedObjectMessage(null, name, version, persistent);
DecodeSharedObject(so, stream, reader);
return so;
}
static void DecodeSharedObject(SharedObjectMessage so, ByteBuffer stream, RtmpReader reader)
{
// Parse request body
while(stream.HasRemaining)
{
byte typeCode = reader.ReadByte();
SharedObjectEventType type = SharedObjectTypeMapping.ToType(typeCode);
string key = null;
object value = null;
int length = stream.GetInt();//reader.ReadInt32();
switch(type)
{
case SharedObjectEventType.CLIENT_STATUS:
// Status code
key = reader.ReadString();
// Status level
value = reader.ReadString();
break;
case SharedObjectEventType.CLIENT_UPDATE_DATA:
{
key = reader.ReadString();
value = reader.ReadData();
/*
key = null;
// Map containing new attribute values
Hashtable map = new Hashtable();
int start = (int)stream.Position;
while((int)stream.Position - start < length)
{
string tmp = reader.ReadString();
map[tmp] = reader.ReadData();
}
value = map;
*/
}
break;
default:
if (type != SharedObjectEventType.SERVER_SEND_MESSAGE && type != SharedObjectEventType.CLIENT_SEND_MESSAGE)
{
if (length > 0)
{
key = reader.ReadString();
if(length > key.Length + 2)
{
value = reader.ReadData();
}
}
}
else
{
int start = (int)stream.Position;
// the "send" event seems to encode the handler name
// as complete AMF string including the string type byte
key = reader.ReadData() as string;
// read parameters
#if !(NET_1_1)
List<object> paramList = new List<object>();
#else
ArrayList paramList = new ArrayList();
#endif
while (stream.Position - start < length)
{
object tmp = reader.ReadData();
paramList.Add(tmp);
}
value = paramList;
}
break;
}
so.AddEvent(type, key, value);
}
}
private static void SendSOPersistenceMismatch(RtmpConnection connection, string name, bool persistent)
{
SharedObjectMessage msg;
if (connection.ObjectEncoding == ObjectEncoding.AMF0)
msg = new SharedObjectMessage(name, 0, persistent);
else
msg = new FlexSharedObjectMessage(name, 0, persistent);
msg.AddEvent(new SharedObjectEvent(SharedObjectEventType.CLIENT_STATUS, StatusASO.SO_PERSISTENCE_MISMATCH, "error"));
connection.GetChannel((byte)3).Write(msg);
}
private static void SendSOCreationFailed(RtmpConnection connection, string name, bool persistent)
{
SharedObjectMessage msg;
if (connection.ObjectEncoding == ObjectEncoding.AMF0)
msg = new SharedObjectMessage(name, 0, persistent);
else
msg = new FlexSharedObjectMessage(name, 0, persistent);
msg.AddEvent(new SharedObjectEvent(SharedObjectEventType.CLIENT_STATUS, StatusASO.SO_CREATION_FAILED, "error"));
connection.GetChannel((byte)3).Write(msg);
}
protected override void OnSharedObject(RtmpConnection connection, RtmpChannel channel, RtmpHeader header, SharedObjectMessage message)
{
ISharedObject so = null;
string name = message.Name;
IScope scope = connection.Scope;
bool persistent = message.IsPersistent;
if(scope == null)
{
// The scope already has been deleted.
SendSOCreationFailed(connection, name, persistent);
return;
}
ISharedObjectService sharedObjectService = ScopeUtils.GetScopeService(scope, typeof(ISharedObjectService)) as ISharedObjectService;
if (!sharedObjectService.HasSharedObject(scope, name))
{
ISharedObjectSecurityService securityService = ScopeUtils.GetScopeService(scope, typeof(ISharedObjectSecurityService)) as ISharedObjectSecurityService;
if (securityService != null)
{
// Check handlers to see if creation is allowed
IEnumerator enumerator = securityService.GetSharedObjectSecurity();
while(enumerator.MoveNext())
{
ISharedObjectSecurity handler = enumerator.Current as ISharedObjectSecurity;
if (!handler.IsCreationAllowed(scope, name, persistent))
{
SendSOCreationFailed(connection, name, persistent);
return;
}
}
}
if (!sharedObjectService.CreateSharedObject(scope, name, persistent))
{
SendSOCreationFailed(connection, name, persistent);
return;
}
}
so = sharedObjectService.GetSharedObject(scope, name);
if (so.IsPersistentObject != persistent)
{
log.Debug(string.Format("Shared object '{0}' persistence mismatch", name));
SendSOPersistenceMismatch(connection, name, persistent);
return;
}
so.DispatchEvent(message);
}
/// <summary> /// This method supports the Fluorine infrastructure and is not intended to be used directly from your code. /// </summary> /// <param name="connection"></param> /// <param name="channel"></param> /// <param name="header"></param> /// <param name="message"></param> protected abstract void OnSharedObject(RtmpConnection connection, RtmpChannel channel, RtmpHeader header, SharedObjectMessage message);
/// <summary>
/// Send update notification over data channel of RTMP connection
/// </summary>
private void SendUpdates()
{
int currentVersion = _version.Value;
bool persist = this.IsPersistentObject;
//Get read-only version of events
ConcurrentLinkedQueue <ISharedObjectEvent> events = new ConcurrentLinkedQueue <ISharedObjectEvent>(_ownerMessage.Events);
//clear out previous events
_ownerMessage.Events.Clear();
if (events.Count != 0)
{
//Send update to "owner" of this update request
if (_source != null)
{
RtmpConnection connection = _source as RtmpConnection;
// Only send updates when issued through RTMP request
RtmpChannel channel = connection.GetChannel((byte)3);
// Send update to "owner" of this update request
SharedObjectMessage syncOwner;
if (connection.ObjectEncoding == ObjectEncoding.AMF0)
{
syncOwner = new SharedObjectMessage(null, _name, currentVersion, persist);
}
else
{
syncOwner = new FlexSharedObjectMessage(null, _name, currentVersion, persist);
}
syncOwner.AddEvents(events);
if (channel != null)
{
channel.Write(syncOwner);
}
else
{
log.Warn(__Res.GetString(__Res.Channel_NotFound));
}
}
}
//Clear owner events
events.Clear();
//Get read-only version of sync events
events.AddRange(_syncEvents);
//Clear out previous events
_syncEvents.Clear();
if (events.Count != 0)
{
// Synchronize updates with all registered clients of this shared
foreach (IEventListener listener in _listeners)
{
if (listener == _source)
{
// Don't re-send update to active client
continue;
}
if (!(listener is RtmpConnection))
{
log.Warn(__Res.GetString(__Res.SharedObject_SyncConnError));
continue;
}
// Create a new sync message for every client to avoid
// concurrent access through multiple threads
// TODO: perhaps we could cache the generated message
RtmpConnection connection = listener as RtmpConnection;
SharedObjectMessage syncMessage;
if (connection.ObjectEncoding == ObjectEncoding.AMF0)
{
syncMessage = new SharedObjectMessage(null, _name, currentVersion, persist);
}
else
{
syncMessage = new FlexSharedObjectMessage(null, _name, currentVersion, persist);
}
syncMessage.AddEvents(events);
RtmpChannel channel = connection.GetChannel((byte)3);
log.Debug(__Res.GetString(__Res.SharedObject_Sync, channel));
channel.Write(syncMessage);
}
}
}
/// <summary>
/// Initializes a new instance of the SharedObject class. This is used by the persistence framework.
/// </summary>
public SharedObject()
{
_ownerMessage = new SharedObjectMessage(null, null, -1, false);
_persistentSO = false;
_creationTime = System.Environment.TickCount;
}