public IDisposable RegisterNotification(NotificationRequest request, IObserver <NotificationResponse> observer)
{
try
{
ApplyOverrides(request);
foreach (var query in request.Queries)
{
if (query.NotificationMechanism == NotificationMechanism.None)
{
query.NotificationMechanism = _defaultNotificationMechanism;
}
if (query.NotificationLevel == NotificationLevel.None)
{
query.NotificationLevel = _defaultNotificationLevel;
}
if (query.PollInterval <= 0)
{
query.PollInterval = _defaultPollInterval;
}
if (query.PollInterval != 0)
{
if (request.ResponsesPerSecond == 0 || (1000 / query.PollInterval) > request.ResponsesPerSecond)
{
request.ResponsesPerSecond = (double)1000 / (double)query.PollInterval;
}
}
}
if (request.NotificationsPerResponse == 0)
{
request.NotificationsPerResponse = 1;
}
return(_provider.RegisterNotification(request, observer));
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
{
_log.ErrorFormat("Failed to register notificaton request: {0}", ex.Message);
}
throw ex;
}
}
public IDisposable RegisterNotification(NotificationRequest request, IObserver <NotificationResponse> observer)
{
try
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Registering notification request: {0}", request.Id);
foreach (var query in request.Queries)
{
_log.DebugFormat("Notification query: {0}, {1}", query.Name, query.Sql);
}
}
lock (SynchLock)
{
if (RequestHandlers.Count == 0)
{
OnFirstSubscription();
}
var requestObserver = new RequestObserver(observer);
RequestHandlers.AddOrUpdate(request, requestObserver, (k, v) => requestObserver);
Parallel.ForEach(request.Queries, query =>
{
if (!_queryHandlers.ContainsKey(query.Name))
{
try
{
lock (_queryHandlers)
{
T_Handler handler = new T_Handler();
handler.Initialise(this, query);
_queryHandlers.Add(query.Name, handler);
}
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
{
_log.ErrorFormat("Failed to register notification query: {0} for request: {1} - {2}", query.Name, request.Id, ex.Message);
}
}
}
var queryHandler = _queryHandlers[query.Name];
var subscription = queryHandler.Subscribe(Observer.Create <Notification>(OnQueryNotification));
request.Subscriptions.Add(subscription);
});
}
return(new Unsubscriber(this, request));
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
{
_log.ErrorFormat("Failed to register notification request: {0} - {1}", request.Id, ex.Message);
}
throw ex;
}
}
public Unsubscriber(NotificationProvider <T_Handler> provider, NotificationRequest request)
{
this.Request = request;
this.Provider = provider;
}
private void ApplyOverrides(NotificationRequest request)
{
try
{
List <INotificationQuery> newQueries = new List <INotificationQuery>();
foreach (INotificationQuery query in request.Queries)
{
NotificationTable table = query as NotificationTable;
if (table == null)
{
newQueries.Add(query);
}
else
{
var tableOverride = _config.TableOverrides.GetTable(table.Name, _databaseType, _databaseName);
if (tableOverride == null)
{
newQueries.Add(query);
}
else
{
if (tableOverride.Overrides.Count == 0)
{
table.PollInterval = tableOverride.PollInterval == 0 ? table.PollInterval : tableOverride.PollInterval;
table.NotificationMechanism = tableOverride.NotificationMechanism == NotificationMechanism.None ? table.NotificationMechanism : tableOverride.NotificationMechanism;
table.NotificationLevel = tableOverride.NotificationLevel == NotificationLevel.None ? table.NotificationLevel : tableOverride.NotificationLevel;
newQueries.Add(table);
if (_log.IsInfoEnabled)
{
_log.InfoFormat("Notification Table override: {0}, Poll Interval={1}, Poll Mechanism={2}", table.Name, table.PollInterval, table.NotificationMechanism);
}
}
else
{
foreach (TableElement newTable in tableOverride.Overrides)
{
string newTableName = newTable.Table;
string[] newTableKey = null;
if (!string.IsNullOrEmpty(newTable.Key))
{
newTableKey = newTable.Key.Split(',');
}
NotificationMechanism newNotificationMechanism = newTable.NotificationMechanism == NotificationMechanism.None ? tableOverride.NotificationMechanism : newTable.NotificationMechanism;
newNotificationMechanism = newNotificationMechanism == NotificationMechanism.None ? table.NotificationMechanism : newNotificationMechanism;
NotificationLevel newNotificationLevel = newTable.NotificationLevel == NotificationLevel.None ? tableOverride.NotificationLevel : newTable.NotificationLevel;
newNotificationLevel = newNotificationLevel == NotificationLevel.None ? table.NotificationLevel : newNotificationLevel;
int newPollInterval = newTable.PollInterval == 0 ? tableOverride.PollInterval : newTable.PollInterval;
newPollInterval = newPollInterval == 0 ? table.PollInterval : newPollInterval;
newQueries.Add(new NotificationTable(newTableName, newNotificationMechanism, newNotificationLevel, newPollInterval, newTableName, newTableKey));
if (_log.IsInfoEnabled)
{
_log.InfoFormat("Notification Table override: {0}, New Table={1}, New Table Key='{2}', Poll Interval={3}, Notification Mechanism={4}, Notification Level={4}", table.Name, newTableName, newTable.Key, newPollInterval, newNotificationMechanism, newNotificationLevel);
}
}
}
}
}
}
request.Queries = newQueries.ToArray();
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
{
foreach (var query in request.Queries)
{
_log.ErrorFormat("Failed to apply table overloads: {0}", query.Name, ex.Message);
}
}
}
}
