internal void Requeue(ServiceEventMessage message)
{
if (message.MessagePublishMode == TMessagePublishMode.FireAndForget && (!_Terminate))
{
StartFireAndForgetThread();
lock (_FireAndForgetMessages)
{
_FireAndForgetMessages.Enqueue(new QueuedMessage()
{
RoutingKey = message.Queue, Message = message, Requeued = true
});
}
_TriggerPublishFireAndForgetMessages.Set();
}
else if (message.MessagePublishMode == TMessagePublishMode.Confirms && (!_Terminate))
{
StartConfirmsThread();
WriteMessageToDisk(message.Queue, message, _ConfirmsRequeueMessagePath);
_TriggerPublishConfirmMessages.Set();
}
else
{
StartTransactionalThread();
WriteMessageToDisk(message.Queue, message, _TransactionalRequeueMessagePath);
_TriggerPublishTransactionalMessages.Set();
}
}
public void AckMessage(ServiceEventMessage message)
{
for (int index = 0; index < _ServerCount; index++)
{
_Subscriptions[index].AckMessage(message);
}
}
private void InvokeCallBack(IAsyncResult asyncResult)
{
MessageArrivedState state = asyncResult.AsyncState as MessageArrivedState;
if (state != null)
{
ServiceEventMessage message = state.Message;
try
{
state.Handler.EndInvoke(asyncResult);
}
catch (Exception ex)
{
ApplicationEventLog.WriteEntry("Flow", ex.ToString(), System.Diagnostics.EventLogEntryType.Error);
message.QueueAfterTime = DateTime.UtcNow.AddSeconds(1.0);
NackMessage(message);
}
lock (state.AckMessageInfo)
{
state.AckMessageInfo.Total = state.AckMessageInfo.Total + 1;
if (state.AckMessageInfo.Total == state.AckMessageInfo.TotalExpected)
{
RespondToMessage(message, state.Queue, state.AckMessageInfo);
state.AckMessageInfo.ChannelHandler.ProcessedMessage();
}
}
}
}
public void SaveSubscription(Subscription subscription, TObjectState state)
{
ServiceEventMessage message = new ServiceEventMessage();
message.AddParameter("SubscriptionID", StringUtils.GuidEncode(subscription.SubscriptionID));
switch (state)
{
case TObjectState.Add:
DataAccessFactory.Subscriptions.SaveSubscription(subscription, state);
BusinessLogicFactory.ServiceMessages.Publish(RouteKeys.SUBSCRIPTION_CREATE, message, TMessagePublishMode.Confirms);
break;
case TObjectState.Update:
DataAccessFactory.Subscriptions.SaveSubscription(subscription, state);
BusinessLogicFactory.ServiceMessages.Publish(RouteKeys.SUBSCRIPTION_UPDATE, message, TMessagePublishMode.Confirms);
break;
case TObjectState.Delete:
BusinessLogicFactory.ServiceMessages.Publish(RouteKeys.SUBSCRIPTION_DELETE, message, TMessagePublishMode.Confirms);
break;
default:
DataAccessFactory.Subscriptions.SaveSubscription(subscription, state);
break;
}
}
public MessageArrivedState(MessageArrivedEventHandler handler, ServiceEventMessage message, MessageQueue queue, AckMessageInfo ackMessageInfo)
{
AckMessageInfo = ackMessageInfo;
Handler = handler;
Message = message;
Queue = queue;
}
private bool ServiceWarningMessageEqual(ServiceEventMessage x, ServiceEventMessage y)
{
return(x.Type == y.Type &&
StringEqual(x.Id, y.Id) &&
x.Kind == y.Kind &&
StringEqual(x.Message, y.Message));
}
private void OnBootstrapStart(string server, ServiceEventMessage message)
{
BootstrapServer bootstrap = (BootstrapServer)message.Parameters["BootstrapServer"];
DataAccessFactory.Configuration.SaveBootstrapServer(bootstrap, TObjectState.Add);
BusinessLogicFactory.ServiceMessages.AckMessage(message);
}
private void OnLWM2MServerStart(string server, ServiceEventMessage message)
{
LWM2MServer lwm2mServer = (LWM2MServer)message.Parameters["Server"];
DataAccessFactory.Servers.SaveLWM2MServer(lwm2mServer, TObjectState.Add);
BusinessLogicFactory.ServiceMessages.AckMessage(message);
}
private void ReadQueueFromDisk(Queue <QueuedMessage> queue, string path)
{
if (Directory.Exists(path))
{
MessageFormatter messageFormatter = new MessageFormatter();
foreach (string item in Directory.GetFiles(path, "*.msg"))
{
if (File.Exists(item))
{
ServiceEventMessage message = null;
using (FileStream stream = File.OpenRead(item))
{
message = messageFormatter.Deserialise(stream);
stream.Close();
}
string filename = Path.GetFileNameWithoutExtension(item);
string routingKey = string.Empty;
int index = filename.IndexOf('_');
if (index != -1)
{
routingKey = filename.Substring(0, index);
}
if (!string.IsNullOrEmpty(routingKey))
{
queue.Enqueue(new QueuedMessage()
{
RoutingKey = routingKey, Message = message
});
}
DeleteMessageFile(item);
}
}
}
}
public void Serialise(Stream stream, ServiceEventMessage message)
{
JsonTextWriter jsonTextWriter = new JsonTextWriter(new StreamWriter(stream));
_Serialiser.Serialize(jsonTextWriter, message);
jsonTextWriter.Flush();
jsonTextWriter.Close();
}
private static async void OnSubscriptionNotify(string server, ServiceEventMessage message)
{
#if DEBUG
Console.WriteLine("Consumed OnSubscriptionNotify message");
Console.WriteLine("Server: " + server);
Console.WriteLine("Message: " + message.ToString());
#endif
string url = (string)message.Parameters["Url"];
string clientID = (string)message.Parameters["ClientID"];
Model.WebhookNotification notification = new Model.WebhookNotification();
MemoryStream stream = new MemoryStream(16384);
new ServiceModels.WebhookNotification(notification, message).Serialise(stream);
string payload = new StreamReader(stream).ReadToEnd();
bool retry = message.Parameters.ContainsKey("RequeueCount");
long requeueCount = retry ? (long)message.Parameters["RequeueCount"] : 0;
bool dropMessage = false;
#if DEBUG
Console.WriteLine($"Sending payload to {url}: \n" + payload);
#endif
try
{
RESTClient.RESTResponse response = await RESTClient.PostAsync(url, ACCEPT_TYPE, null, notification.AcceptContentType, payload);
switch ((HttpStatusCode)response.StatusCode)
{
case HttpStatusCode.OK:
case HttpStatusCode.Created:
ApplicationEventLog.Write(LogLevel.Information, $"Webhook post notification from client {clientID} to {url} successful.");
break;
case HttpStatusCode.BadRequest:
case HttpStatusCode.Unauthorized:
case HttpStatusCode.NotFound:
case HttpStatusCode.MethodNotAllowed:
// No retry for these failures
ApplicationEventLog.Write(LogLevel.Warning, $"Non-recoverable HTTP Status code from{url}:{response.StatusCode}, discarding message.");
dropMessage = true;
break;
default:
ApplicationEventLog.Write(LogLevel.Warning, $"Unexpected HTTP Status code from{url}:{response.StatusCode}");
break;
}
}
catch (Exception ex)
{
ApplicationEventLog.Write(LogLevel.Error, "Failed to post webhook", ex);
}
if ((MAX_POST_ATTEMPTS <= 0 || requeueCount < MAX_POST_ATTEMPTS) && !dropMessage)
{
BusinessLogicFactory.ServiceMessages.NackMessage(message);
}
}
public void ClientUpdate(LWM2MClient client)
{
if (client.OrganisationID != 0)
{
ServiceEventMessage message = new ServiceEventMessage();
FillDeviceParameters(client, message);
BusinessLogicFactory.ServiceMessages.Publish(RouteKeys.CLIENT_UPDATE, message, TMessagePublishMode.Confirms);
}
}
private static void OnObservationNotify(string server, ServiceEventMessage message)
{
#if DEBUG
Console.WriteLine("Consumed OnObservationNotify message");
Console.WriteLine("Server: " + server);
Console.WriteLine("Message: " + message.ToString());
#endif
NotifySubscribers(message, TSubscriptionType.Observation);
}
public void ClientConnectionExpired(LWM2MClient client)
{
if (client.OrganisationID != 0)
{
ServiceEventMessage message = new ServiceEventMessage();
FillDeviceParameters(client, message);
BusinessLogicFactory.ServiceMessages.Publish(RouteKeys.CLIENT_CONNECTION_EXPIRED, message, TMessagePublishMode.Confirms);
}
}
public void Publish(string routingKey, ServiceEventMessage message, int organisationID, string locale, TMessagePublishMode publishMode)
{
CheckRabbitMQ();
if (!message.Parameters.ContainsKey("OrganisationID"))
{
message.Parameters.Add("OrganisationID", organisationID);
}
_DALRabbitMQ.Publish(routingKey, message, publishMode);
}
public void Publish(string routingKey, ServiceEventMessage message, TMessagePublishMode publishMode)
{
CheckRabbitMQ();
if (Security.CurrentOrganisation != null && !message.Parameters.ContainsKey("OrganisationID"))
{
message.Parameters.Add("OrganisationID", Security.CurrentOrganisation.OrganisationID);
}
_DALRabbitMQ.Publish(routingKey, message, publishMode);
}
private static void OnClientConnectionExpired(string server, ServiceEventMessage message)
{
#if DEBUG
Console.WriteLine("Consumed OnClientConnectionExpired message");
Console.WriteLine("Server: " + server);
Console.WriteLine("Message: " + message.ToString());
#endif
NotifySubscribers(message, TSubscriptionType.ClientConnectionExpired);
}
public void ObservationNotify(LWM2MClient client, Model.Object lwm2mObject)
{
if (client.OrganisationID != 0)
{
ServiceEventMessage message = new ServiceEventMessage();
FillDeviceParameters(client, message);
message.Parameters.Add("Object", lwm2mObject);
BusinessLogicFactory.ServiceMessages.Publish(RouteKeys.OBSERVATION_NOTIFICATION, message, TMessagePublishMode.Confirms);
}
}
public void MetricsUpdate(LWM2MClient client)
{
if (client.OrganisationID != 0)
{
ServiceEventMessage message = new ServiceEventMessage();
FillDeviceParameters(client, message);
client.Metrics.FillParameters(message);
BusinessLogicFactory.ServiceMessages.Publish(RouteKeys.CLIENT_METRICS, message, TMessagePublishMode.Confirms);
client.Metrics.ResetIncrementalMetrics();
}
}
private void OnUpdateMetrics(string server, ServiceEventMessage message)
{
Guid clientID = StringUtils.GuidDecode((string)message.Parameters["ClientID"]);
int organisationID = (int)((long)message.Parameters["OrganisationID"]);
List <ClientMetric> metrics = (List <ClientMetric>)message.Parameters["Metrics"];
foreach (ClientMetric parameter in metrics)
{
string metricName = parameter.Name;
long oldValue = 0;
long newValue = parameter.Value;
ClientMetric clientMetric = DataAccessFactory.Metrics.GetMetric(clientID, metricName);
if (clientMetric == null)
{
clientMetric = new ClientMetric();
clientMetric.Name = metricName;
clientMetric.Value = newValue;
clientMetric.ClientID = clientID;
clientMetric.Incremental = parameter.Incremental;
DataAccessFactory.Metrics.SaveMetric(clientMetric, TObjectState.Add);
}
else
{
oldValue = clientMetric.Value;
if (clientMetric.Incremental)
{
clientMetric.Value += newValue;
newValue = clientMetric.Value;
}
else
{
clientMetric.Value = newValue;
}
DataAccessFactory.Metrics.SaveMetric(clientMetric, TObjectState.Update);
}
long change = newValue - oldValue;
OrganisationMetric organisationMetric = DataAccessFactory.Metrics.GetMetric(organisationID, metricName);
if (organisationMetric == null)
{
organisationMetric = new OrganisationMetric();
organisationMetric.Name = metricName;
organisationMetric.Value = change;
organisationMetric.OrganisationID = organisationID;
DataAccessFactory.Metrics.SaveMetric(organisationMetric, TObjectState.Add);
}
else
{
organisationMetric.Value += change;
DataAccessFactory.Metrics.SaveMetric(organisationMetric, TObjectState.Update);
}
}
}
public void NackMessage(ServiceEventMessage message)
{
if (!message.QueueAfterTime.HasValue)
{
message.QueueAfterTime = DateTime.UtcNow.AddSeconds(1.0);
}
for (int index = 0; index < _ServerCount; index++)
{
_Subscriptions[index].NackMessage(message);
}
}
public void NackMessage(ServiceEventMessage message, TimeSpan?delayQueueingFor = null)
{
CheckRabbitMQ();
if (delayQueueingFor.HasValue)
{
_DALRabbitMQ.NackMessage(message, delayQueueingFor.Value);
}
else
{
_DALRabbitMQ.NackMessage(message);
}
}
private static void RestartObservations(ServiceEventMessage message)
{
Guid clientID = StringUtils.GuidDecode((string)message.Parameters["ClientID"]);
#if DEBUG
Console.WriteLine($"Restarting observations for client {clientID}");
#endif
List <Subscription> subscriptions = DataAccessFactory.Subscriptions.GetSubscriptions(clientID);
foreach (Subscription subscription in subscriptions)
{
if (subscription.SubscriptionType == TSubscriptionType.Observation)
{
Observe(subscription);
}
}
}
private void RespondToMessage(ServiceEventMessage message, MessageQueue messageQueue, AckMessageInfo ackMessageInfo)
{
try
{
messageQueue.Messages.Remove(ackMessageInfo.DeliveryID);
if (ackMessageInfo.TotalNack == 0)
{
if (ackMessageInfo.TotalAck == 0)
{
_DALRabbitMQ.Reject(message);
}
if (messageQueue.Channel != null && messageQueue.Channel.IsOpen)
{
messageQueue.Channel.BasicAck(ackMessageInfo.DeliveryTag, false);
}
}
else
{
if (message.Parameters.ContainsKey("RequeueCount"))
{
message.Parameters["RequeueCount"] = (int)((long)(message.Parameters["RequeueCount"])) + 1;
}
else
{
message.Parameters.Add("RequeueCount", (int)1);
}
_DALRabbitMQ.Requeue(message);
if (!message.QueueAfterTime.HasValue)
{
Thread.Sleep(50);
}
if (messageQueue.Channel != null && messageQueue.Channel.IsOpen)
{
messageQueue.Channel.BasicAck(ackMessageInfo.DeliveryTag, false);
}
//_Model.BasicReject(ackMessageInfo.DeliveryTag, true);
}
}
catch (Exception ex)
{
_ConnectionShutdown = true;
_TriggerSubscriptionRequest.Set();
ApplicationEventLog.WriteEntry("Flow", string.Concat("Failed to Ack/Nack", messageQueue.QueueName, ":\r\n", ex.ToString()), System.Diagnostics.EventLogEntryType.Error);
}
}
private static void NotifySubscriber(Guid clientID, Subscription subscription, Model.Object changedObject)
{
#if DEBUG
Console.WriteLine("Publishing Subscription.Webhook message for subscription " + subscription.SubscriptionID);
#endif
ServiceEventMessage message = new ServiceEventMessage();
message.AddParameter("AcceptContentType", subscription.AcceptContentType);
message.AddParameter("SubscriptionID", StringUtils.GuidEncode(subscription.SubscriptionID));
message.AddParameter("SubscriptionType", subscription.SubscriptionType.ToString());
message.AddParameter("ClientID", StringUtils.GuidEncode(clientID));
message.AddParameter("Url", subscription.Url);
message.AddParameter("TimeTriggered", DateTime.Now);
if (changedObject != null)
{
message.AddParameter("Object", changedObject);
}
BusinessLogicFactory.ServiceMessages.Publish(RouteKeys.SUBSCRIPTION_NOTIFICATION, message, TMessagePublishMode.Confirms);
}
public void NackMessage(ServiceEventMessage message)
{
MessageQueue messageQueue;
if (_Queues.TryGetValue(message.Queue, out messageQueue))
{
AckMessageInfo ackMessageInfo;
lock (messageQueue.Messages)
{
if (messageQueue.Messages.TryGetValue(message.DeliveryID, out ackMessageInfo))
{
lock (ackMessageInfo)
{
ackMessageInfo.TotalNack = ackMessageInfo.TotalNack + 1;
}
}
}
}
}
private static void NotifySubscribers(ServiceEventMessage message, TSubscriptionType subscriptionType)
{
Guid clientID = StringUtils.GuidDecode((string)message.Parameters["ClientID"]);
int organisationID = (int)((long)message.Parameters["OrganisationID"]);
Model.Object changedObject = null;
List <Subscription> subscriptions = null;
if (subscriptionType == TSubscriptionType.Observation)
{
changedObject = (Model.Object)message.Parameters["Object"];
subscriptions = DataAccessFactory.Subscriptions.GetSubscriptions(clientID);
}
else
{
subscriptions = DataAccessFactory.Subscriptions.GetSubscriptions(organisationID);
}
foreach (Subscription subscription in subscriptions)
{
if (subscription.SubscriptionType == subscriptionType)
{
if (subscriptionType == TSubscriptionType.Observation)
{
if (subscription.ObjectDefinitionID == changedObject.ObjectDefinitionID)
{
if (subscription.ObjectID == null || subscription.ObjectID == changedObject.InstanceID)
{
if (subscription.PropertyDefinitionID == Guid.Empty || changedObject.ContainsPropertyWithDefinitionID(subscription.PropertyDefinitionID))
{
NotifySubscriber(clientID, subscription, changedObject);
}
}
}
}
else
{
NotifySubscriber(clientID, subscription, changedObject);
}
}
}
}
public WebhookNotification(Model.WebhookNotification webhookNotification, ServiceEventMessage message)
{
_WebhookNotification = webhookNotification;
_WebhookNotification.AcceptContentType = (string)message.Parameters["AcceptContentType"];
_WebhookNotification.SubscriptionID = (string)message.Parameters["SubscriptionID"];
_WebhookNotification.ClientID = (string)message.Parameters["ClientID"];
_WebhookNotification.SubscriptionType = (string)message.Parameters["SubscriptionType"];
_WebhookNotification.TimeTriggered = (DateTime)message.Parameters["TimeTriggered"];
if (message.Parameters.ContainsKey("Object"))
{
_WebhookNotification.ChangedObject = (Model.Object)message.Parameters["Object"];
_WebhookNotification.ObjectDefinition = DataAccessFactory.ObjectDefinitions.GetLookups().GetObjectDefinition(_WebhookNotification.ChangedObject.ObjectDefinitionID);
if (_WebhookNotification.ObjectDefinition == null)
{
ApplicationEventLog.Write(LogLevel.Warning, $"Could not lookup object definition {_WebhookNotification.ChangedObject.ObjectDefinitionID}");
}
}
}
private void WriteMessageToDisk(string routingKey, ServiceEventMessage message, string path)
{
string filename = Path.Combine(path, string.Concat(routingKey, "_", message.MessageID, ".lck"));
lock (this)
{
string messageFilename = Path.ChangeExtension(filename, ".msg");
if (!File.Exists(messageFilename))
{
using (FileStream stream = new FileStream(filename, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite, 4096, FileOptions.None))
{
MessageFormatter messageFormatter = new MessageFormatter(stream);
messageFormatter.Serialise(message);
stream.Flush();
stream.Close();
}
File.Move(filename, messageFilename);
}
}
}
private void UpdateClientsConnectedMetric(string server, ServiceEventMessage message)
{
int organisationID = (int)((long)message.Parameters["OrganisationID"]);
OrganisationMetric clientsConnectedMetric = DataAccessFactory.Metrics.GetMetric(organisationID, MetricNames.NumberClients);
int numClientsConnected = BusinessLogicFactory.Clients.GetConnectedClients(organisationID).Count;
if (clientsConnectedMetric == null)
{
clientsConnectedMetric = new OrganisationMetric();
clientsConnectedMetric.Name = MetricNames.NumberClients;
clientsConnectedMetric.Value = Math.Max(numClientsConnected, 0);
clientsConnectedMetric.OrganisationID = organisationID;
DataAccessFactory.Metrics.SaveMetric(clientsConnectedMetric, TObjectState.Add);
}
else
{
clientsConnectedMetric.Value = numClientsConnected;
DataAccessFactory.Metrics.SaveMetric(clientsConnectedMetric, TObjectState.Update);
}
}
