/// <summary>
/// Creates a subscription to the specified Item.
/// </summary>
/// <remarks>
/// <para>
/// Upon the addition of the initial subscriber, an entry is added to the <see cref="Subscriptions"/> Dictionary
/// keyed with the specified Item with a new <see cref="List{T}"/> of type <see cref="Action{T}"/> containing one
/// entry corresponding to the specified callback delegate.
/// </para>
/// <para>
/// Successive additions add each of the specified callback delegates to the <see cref="Subscriptions"/> dictionary.
/// </para>
/// </remarks>
/// <param name="item">The <see cref="Item"/> to which the subscription should be added.</param>
/// <param name="callback">The callback delegate to be invoked upon change of the subscribed Item.</param>
/// <returns>A value indicating whether the operation succeeded.</returns>
public bool Subscribe(Item item, Action <object> callback)
{
logger.EnterMethod(xLogger.Params(item, callback));
logger.Debug("Subscribing to Item '" + item.FQN + "' on Provider '" + ItemProviderName + "'...");
bool retVal = false;
if (!Subscriptions.ContainsKey(item))
{
logger.Debug("The Item '" + item.FQN + "' has been added to the Subscriptions list.");
Subscriptions.Add(item, new List <Action <object> >());
}
if (Subscriptions[item].Where(c => ReferenceEquals(c, callback)).Count() <= 0)
{
int count = Subscriptions[item].Count;
Subscriptions[item].Add(callback);
logger.Debug("Subscriptions to Item '" + item.FQN + "' on Provider '" + ItemProviderName + "' changed from " + count + " to " + Subscriptions[item].Count + ".");
retVal = true;
}
else
{
logger.Debug("The specified item '" + item.FQN + "' and callback '" + callback?.Target?.ToString() + "' has already been subscribed.");
}
logger.ExitMethod(retVal);
return(retVal);
}
/// <summary>
/// Removes a subscription from the specified ConnectorItem.
/// </summary>
/// <remarks>
/// <para>
/// Upon the removal of a subscriber the specified callback delegate is removed from the corresponding Dictionary
/// entry for the specified <see cref="Item"/>.
/// </para>
/// Upon removal of the final subscriber, the Dictionary key corresponding to the specified <see cref="Item"/> is
/// completely removed.
/// </remarks>
/// <param name="item">The <see cref="Item"/> for which the subscription should be removed.</param>
/// <param name="callback">The callback delegate to be invoked upon change of the subscribed Item.</param>
/// <returns>A value indicating whether the operation succeeded.</returns>
public bool UnSubscribe(Item item, Action <object> callback)
{
bool retVal = false;
try
{
if (Subscriptions.ContainsKey(item))
{
Subscriptions[item].Remove(callback);
if (Subscriptions[item].Count == 0)
{
Subscriptions.Remove(item);
}
retVal = true;
}
}
catch (Exception ex)
{
logger.Exception(ex);
}
return(retVal);
}
public void AddSubscription(Subscription subscription)
{
if (!Subscriptions.ContainsKey(subscription.UserId))
{
Subscriptions.Add(subscription.UserId, subscription);
}
}
public bool Add(dynamic handler, string subscriberID, int povDirection = 0)
{
if (povDirection == 0)
{
// Regular mapping
if (Subscriptions.ContainsKey(subscriberID))
{
Subscriptions[subscriberID].Callback = handler;
}
else
{
Subscriptions.Add(subscriberID, new Subscription(handler));
}
return(true);
}
else
{
//Pov Direction Mapping
if (povDirection < 1 || povDirection > 4)
{
return(false);
}
if (!PovDirectionSubscriptions.ContainsKey(povDirection))
{
PovDirectionSubscriptions.Add(povDirection, new SubscribedPovDirection(povDirection));
}
return(PovDirectionSubscriptions[povDirection].Add(subscriberID, handler));
}
}
/// <summary>
/// Subscribe to channel
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="channelName"></param>
/// <param name="action"></param>
/// <returns></returns>
public Task Subscribe <T>(string channelName, Action <T> action) where T : class
{
// Add the process type to the list of subscribed processes
if (!Subscriptions.ContainsKey(channelName))
{
Subscriptions.Add(channelName, (messageBody) =>
{
if (messageBody is T)
{
action(messageBody as T);
}
else
{
var obj = JsonConvert.DeserializeObject <T>(messageBody);
action(obj);
}
});
}
// Execute all unexecuted processes from the queue (database in this case)
Task.Run(() =>
{
ProcessUnprocessedTasks(channelName, action);
});
return(Task.CompletedTask);
}
public bool Remove(string subscriberID, int povDirection = 0)
{
if (povDirection == 0)
{
// Regular mapping
if (!Subscriptions.ContainsKey(subscriberID))
{
return(false);
}
Subscriptions.Remove(subscriberID);
return(true);
}
else
{
// POV Direction Mapping
if (PovDirectionSubscriptions.ContainsKey(povDirection))
{
var ret = PovDirectionSubscriptions[povDirection].Remove(subscriberID);
if (ret && PovDirectionSubscriptions[povDirection].IsEmpty())
{
PovDirectionSubscriptions.Remove(povDirection);
}
return(ret);
}
return(false);
}
}
protected void ProcessQueuedMessages(XmlStream xml, CancellationToken canceltoken)
{
Message msg;
while (!canceltoken.IsCancellationRequested && QueuedMessages.TryDequeue(out msg))
{
foreach (XElement el in msg.Content)
{
if (el.Name.ToString() == "{google:push}push")
{
string channel = el.Attribute("channel").Value;
if (Subscriptions.ContainsKey(channel))
{
Logger.Log(LogLevel.Debug, "Handling message for channel {0}", channel);
Subscriptions[channel](el, this);
}
else
{
Logger.Log(LogLevel.Debug, "Message for unknown channel {0}", channel);
}
}
}
}
canceltoken.ThrowIfCancellationRequested();
}
/// <summary>
/// Removes a subscription from the specified ConnectorItem.
/// </summary>
/// <remarks>
/// <para>
/// Upon the removal of a subscriber the specified callback delegate is removed from the corresponding Dictionary
/// entry for the specified <see cref="Item"/>.
/// </para>
/// Upon removal of the final subscriber, the Dictionary key corresponding to the specified <see cref="Item"/> is
/// completely removed.
/// </remarks>
/// <param name="item">The <see cref="Item"/> for which the subscription should be removed.</param>
/// <param name="callback">The callback delegate to be invoked upon change of the subscribed Item.</param>
/// <returns>A value indicating whether the operation succeeded.</returns>
public bool UnSubscribe(Item item, Action <object> callback)
{
logger.EnterMethod(xLogger.Params(item, callback));
logger.Debug("UnSubscribing from Item '" + item.FQN + "' on Provider '" + ItemProviderName + "'...");
bool retVal = false;
if (Subscriptions.ContainsKey(item))
{
int count = Subscriptions[item].Count;
Subscriptions[item].Remove(callback);
logger.Debug("Subscriptions to Item '" + item.FQN + "' on Provider '" + ItemProviderName + "' changed from " + count + " to " + Subscriptions[item].Count + ".");
if (Subscriptions[item].Count == 0)
{
Subscriptions.Remove(item);
logger.Debug("Item '" + item.FQN + "' has no further subscribers and has been removed from the Subscriptions list.");
}
retVal = true;
}
else
{
logger.Debug("Subscription for Item '" + item.FQN + "' on Provider '" + ItemProviderName + "' not found.");
}
logger.ExitMethod(retVal);
return(retVal);
}
public bool Remove(string subscriberID, int povDirection)
{
if (!Subscriptions.ContainsKey(subscriberID))
{
return(false);
}
Subscriptions.Remove(subscriberID);
return(true);
}
public bool Add(dynamic handler, string subscriberID, int povDirection)
{
if (Subscriptions.ContainsKey(subscriberID))
{
Subscriptions[subscriberID].Callback = handler;
}
else
{
Subscriptions.Add(subscriberID, new Subscription(handler));
}
return(true);
}
private void OnDynamicImageChange(object sender, FileSystemEventArgs args)
{
logger.Info("File watcher for " + args.FullPath);
Item key = Find("Simulation.Binary.DynamicImage");
if (Subscriptions.ContainsKey(key))
{
foreach (Action <object> callback in Subscriptions[key])
{
callback.Invoke(ReadFile(args.FullPath));
logger.Info("Invoked dynamic image change delegate");
}
}
}
public void SubscribeTo(Type type, Action <RemoteSubscriptionHandle> callback)
{
if (Subscriptions.ContainsKey(type))
{
Subscriptions[type]++;
}
else
{
Subscriptions.Add(type, 1);
}
callback(new RemoteSubscriptionHandle {
PublisherNodeID = EllaConfiguration.Instance.NodeId + 1, PublisherId = 12, SubscriberNodeID = EllaConfiguration.Instance.NodeId
});
}
public void Dispose()
{
if (_isDisposed)
{
return;
}
if (_subscriptions.ContainsKey(_subscription))
{
_subscriptions.TryRemove(_subscription, out _);
}
_isDisposed = true;
GC.SuppressFinalize(this);
}
/// <summary>
/// Removes a subscription from the specified Item.
/// </summary>
/// <remarks>
/// Decrements the number of subscribers within the <see cref="Subscriptions"/> Dictionary. Upon removal of the final
/// subscriber, the subscription is completely removed.
/// </remarks>
/// <param name="item">The <see cref="Item"/> for which the subscription should be removed.</param>
/// <threadsafety instance="true"/>
/// <returns>An <see cref="Result"/> containing the result of the operation.</returns>
public Result UnSubscribe(Item item)
{
logger.EnterMethod(xLogger.Params(item));
logger.Info("Removing Subscription for Item '" + item.FQN + "'...");
Result retVal = new Result();
try
{
// always ensure the key exists before trying to reference it.
if (!Subscriptions.ContainsKey(item))
{
retVal.AddError("The Item '" + item.FQN + "' is not currently subscribed.");
}
else
{
// lock the Subscriptions collection
lock (SubscriptionsLock)
{
// decrement the number of active subscriptions
Subscriptions[item]--;
// if the number of subscriptions is zero (or less than zero somehow), remove it from the dictionary.
if (Subscriptions[item] <= 0)
{
Subscriptions.Remove(item);
retVal.AddInfo("The Item '" + item.FQN + "' has been fully unsubscribed.");
}
else
{
retVal.AddInfo("The Item '" + item.FQN + "' now has " + Subscriptions[item] + " subscriber(s).");
}
}
}
}
catch (Exception ex)
{
retVal.AddError("Error unsubscribing from Item '" + item.FQN + "': " + ex.Message);
}
retVal.LogResult(logger);
logger.ExitMethod(retVal);
return(retVal);
}
public void Subscribe(NatsSubscription natsSubscription)
{
if (Subscriptions.ContainsKey(natsSubscription))
{
return;
}
Logger.Info($"{nameof(Subscribe)}: {natsSubscription.Subject}");
List <IAsyncSubscription> subs = new List <IAsyncSubscription>();
foreach (var conn in ConnectionsByName.Values)
{
IAsyncSubscription sub = conn.SubscribeAsync(natsSubscription.Subject, OnMessage);
subs.Add(sub);
}
Subscriptions[natsSubscription] = subs;
natsSubscription.Subscribed = subs.Any();
Subscribed?.Invoke(natsSubscription);
}
public async Task SubscribeToChunk(ChunkKey key)
{
if (Subscriptions.ContainsKey(key))
{
return;
}
var channel = OutgoingChannel;//copy to local for closure;
var chunkHandlerSubscription = await BattleHandler.GetChunkHandlerAndSubscribeAsync(key, (chunkKey, update) => OnChunkUpdateAsync(key, update, channel));
if (Subscriptions.TryAdd(key, chunkHandlerSubscription))
{
await SendChunkStateAsync(key, chunkHandlerSubscription);
}
else
{
chunkHandlerSubscription.Dispose();
throw new InvalidOperationException("Duplicate subscription is detected.");
}
}
protected void ConfirmDataPushing(string taskName, string subscription, Action taskFunc)
{
lock (taskName)
{
if (DataPushingTasks != null)
{
if (subscription != null)
{
if (!Subscriptions.ContainsKey(taskName))
{
Subscriptions[taskName] = new HashSet <string>();
}
Subscriptions[taskName].Add(subscription);
}
if (!DataPushingTasks.ContainsKey(taskName))
{
DataPushingTasks[taskName] = new Task(() =>
{
while (true)
{
Thread.Sleep(Interval);
lock (Locker)
{
if (!IsOnline)
{
break;
}
taskFunc.Invoke();
}
}
if (DataPushingTasks != null)
{
DataPushingTasks.Remove(taskName);
Subscriptions.Remove(taskName);
}
});
DataPushingTasks[taskName].Start();
}
}
}
}
/// <summary>
/// Creates a subscription to the specified Item.
/// </summary>
/// <remarks>
/// <para>
/// Upon the addition of the initial subscriber, an entry is added to the <see cref="Subscriptions"/> Dictionary
/// keyed with the specified Item with a new <see cref="List{T}"/> of type <see cref="Action{T}"/> containing one
/// entry corresponding to the specified callback delegate.
/// </para>
/// <para>
/// Successive additions add each of the specified callback delegates to the <see cref="Subscriptions"/> dictionary.
/// </para>
/// </remarks>
/// <param name="item">The <see cref="Item"/> to which the subscription should be added.</param>
/// <param name="callback">The callback delegate to be invoked upon change of the subscribed Item.</param>
/// <returns>A value indicating whether the operation succeeded.</returns>
public bool Subscribe(Item item, Action <object> callback)
{
bool retVal = false;
try
{
if (!Subscriptions.ContainsKey(item))
{
Subscriptions.Add(item, new List <Action <object> >());
}
Subscriptions[item].Add(callback);
retVal = true;
}
catch (Exception ex)
{
logger.Exception(ex);
}
return(retVal);
}
/// <summary>
/// Creates a subscription to the specified Item.
/// </summary>
/// <remarks>
/// Upon the addition of the initial subscriber, an entry is added to the <see cref="Subscriptions"/> Dictionary keyed
/// with the specified Item and with a quantity of one. Successive subscriptions increment the quantity by one.
/// </remarks>
/// <param name="item">The <see cref="Item"/> to which the subscription should be added.</param>
/// <threadsafety instance="true"/>
/// <returns>An <see cref="Result"/> containing the result of the operation.</returns>
public Result Subscribe(Item item)
{
logger.EnterMethod(xLogger.Params(item));
logger.Info("Creating new Subscription to Item '" + item.FQN + "'...");
Result retVal = new Result();
try
{
// lock the Subscriptions collection
lock (SubscriptionsLock)
{
// always ensure the key exists before trying to reference it.
if (Subscriptions.ContainsKey(item))
{
// if it exists, increment the number of subscriptions
Subscriptions[item]++;
}
else
{
// if it doesn't yet exist, add it and set the number of subscriptions to 1.
Subscriptions.Add(item, 1);
}
retVal.AddInfo("The Item '" + item.FQN + "' now has " + Subscriptions[item] + " subscriber(s).");
}
}
catch (Exception ex)
{
retVal.AddError("Error subscribing to Item '" + item.FQN + "': " + ex.Message);
}
retVal.LogResult(logger);
logger.ExitMethod(retVal);
return(retVal);
}
