public static async Task Run(TimerInfo getScheduledReadEnergyEarthMessagesTimer, ICollector <string> errormessage, TraceWriter log)
{
if (getScheduledReadEnergyEarthMessagesTimer.IsPastDue)
{
log.Verbose("Timer is running late!", "JE.RMS.Services.ScheduledReadEnergyEarthMessagesFromQueue");
}
try
{
var connectionString = ConfigurationManager.AppSettings["MyServiceBusReader"].ToString();
SubscriptionClient client = SubscriptionClient.CreateFromConnectionString(connectionString, "fulfillmentrequest", "EnergyEarthSubscription");
int batchSize = Convert.ToInt32(ConfigurationManager.AppSettings["ReadEnergyEarthMessageBatchSize"].ToString());
var brokeredMessagesList = client.ReceiveBatch(1);
List <Guid> messageLockTokenList = new List <System.Guid>();
if (brokeredMessagesList.Count() > 0)
{
foreach (BrokeredMessage message in brokeredMessagesList)
{
var raw = message.GetBody <string>();
var RewardFulfillmentRequestList = JsonConvert.DeserializeObject <RewardFulfillmentRequestList>(raw);
using (HttpClient httpClient = new HttpClient())
{
//Add Basic Authentication header
httpClient.BaseAddress = new Uri(ConfigurationManager.AppSettings["ProcessFulfillmentUrl"].ToString());
//log.Verbose($"Calling Update point status API, UserId : {CustomerUniqueId}, with Status : {PointStatus.Status}", "JE.RMS.Services.ProcessFulfillmentForEnergyEarth");
var response = await httpClient.PostAsJsonAsync(string.Empty, RewardFulfillmentRequestList);
if (response.IsSuccessStatusCode)
{
log.Verbose($"Success : Process fulfillment for EE", "JE.RMS.Services.ScheduledReadEnergyEarthMessagesFromQueue");
}
else
{
log.Error($"Error : Process fulfillment for EE", null, "JE.RMS.Services.ScheduledReadEnergyEarthMessagesFromQueue");
}
}
messageLockTokenList.Add(message.LockToken);
}
client.CompleteBatch(messageLockTokenList);
log.Verbose($"Completed : Process fulfillment for EE batch", "JE.RMS.Services.ScheduledReadEnergyEarthMessagesFromQueue");
}
}
catch (Exception ex)
{
log.Error("Something went wrong while ScheduledReadEnergyEarthMessagesFromQueue", ex, "JE.RMS.Services.ScheduledReadEnergyEarthMessagesFromQueue");
errormessage.Add(JsonConvert.SerializeObject(ex).ToString());
}
}
public void ProcessSubscription(SubscriptionClient subscriptionClient, TopicClient destinationTopicClient)
{
_activityLogger.Log($"[{subscriptionClient.TopicPath}].[{subscriptionClient.Name}] - Processing subscription");
var totalMessagesForwarded = 0;
var messagesRemaining = true;
while (messagesRemaining)
{
// get messages in source subscription
var messages = subscriptionClient.ReceiveBatch(_messagesToHandle, _serverWaitTime);
var messageCount = messages.Count();
if (messageCount > 0)
{
_activityLogger.Log($"Batch of {messageCount} message(s) received for processing", 1);
var messagesForwarded = 0;
foreach (var message in messages)
{
if (!_forwardedMessageIds.Contains(message.MessageId)) // ignore duplicate messages, which have already been forwarded
{
// log message
_messageLogger?.Log($"Subscription: [{subscriptionClient.TopicPath}].[{subscriptionClient.Name}]\n" +
$"{message.GetSingleLineContent()}\n");
// send messages to destination topic
destinationTopicClient.Send(message.Clone());
_forwardedMessageIds.Add(message.MessageId);
messagesForwarded++;
totalMessagesForwarded++;
}
message.Complete();
}
_activityLogger.Log($"Processing complete: {messagesForwarded} message(s) forwarded " +
$"({messageCount - messagesForwarded} duplicate(s) from other subscriptions)", 1);
}
else
{
messagesRemaining = false;
_activityLogger.Log($"No {(totalMessagesForwarded > 0 ? "more " : "")}messages to process", 1);
}
}
_activityLogger.Log($"[{subscriptionClient.TopicPath}].[{subscriptionClient.Name}] - Completed processing subscription - {totalMessagesForwarded} message(s) forwarded");
}
protected virtual void StartProcessing <T>(SubscriptionClient subscriptionClient, Action <IEnumerable <T> > messagesReceived)
where T : SubscriptionMessage
{
log.Info("Starting processing");
while (true)
{
log.Info($"Waiting for message batch. BatchSize = {this.BatchSize}");
var messages = subscriptionClient.ReceiveBatch(this.BatchSize);
var brokeredMessages = messages as BrokeredMessage[] ?? messages.ToArray();
log.Info($"Received {brokeredMessages.Count()} messages");
this.ProcessMessages(subscriptionClient, messagesReceived, brokeredMessages);
}
}
public IEnumerable <Message> RetrieveMessages(int messageAmount, int timeout)
{
var brokeredMessages = _client.ReceiveBatch(messageAmount, TimeSpan.FromSeconds(timeout));
var messages = new List <Message>();
foreach (var brokeredMessage in brokeredMessages)
{
var stream = brokeredMessage.GetBody <Stream>();
Message message = new Message(stream,
brokeredMessage.SessionId,
brokeredMessage.Label,
brokeredMessage.Properties);
messages.Add(message);
}
return(messages);
}
public List <Message> RetrieveMessages(int messageAmount, int timeout)
{
var brokeredMessages = _client.ReceiveBatch(messageAmount, TimeSpan.FromSeconds(timeout));
var messages = new List <Message>();
foreach (var brokeredMessage in brokeredMessages)
{
Message message = new Message();
var stream = brokeredMessage.GetBody <Stream>();
message.Content = _serializer.ParseMessage <object>(stream);
message.Label = brokeredMessage.Label;
message.SessionId = brokeredMessage.SessionId;
message.Properties = new Dictionary <string, object>(brokeredMessage.Properties);
messages.Add(message);
}
return(messages);
}
/// <summary>
/// Starts listening for messages on the configured Service Bus Subscription.
/// </summary>
private void ListenForMessages()
{
ThreadStart ts = () =>
{
while (!StopProcessingMessageToken.IsCancellationRequested)
{
var messages = _serviceBusClient.ReceiveBatch(ServiceBusMessageBatchSize, ServiceBusServerTimeout);
foreach (var message in messages)
{
if (StopProcessingMessageToken.IsCancellationRequested)
{
break;
}
ReceiveMessage(message);
}
}
};
StartBackgroundThread(ts);
}
protected override void StartProcessing <T1>(SubscriptionClient subscriptionClient, Action <IEnumerable <T1> > messagesReceived)
{
log.Info($"Initialising batcher. BatchSize={BatchSize}, MaxTimeToWaitForBatch={maxTimeToWaitForBatch}");
var batcher = new Batcher <BrokeredMessage>(messages => ProcessMessages(subscriptionClient, messagesReceived, messages), BatchSize, this.maxTimeToWaitForBatch);
log.Info("Batcher initialised");
while (true)
{
log.Info("Waiting to receive batch");
var batch = subscriptionClient.ReceiveBatch(BatchSize);
var brokeredMessages = batch as BrokeredMessage[] ?? batch.ToArray();
log.Info($"Received batch of {brokeredMessages.Length} messages");
foreach (var brokeredMessage in brokeredMessages)
{
batcher.Post(brokeredMessage);
}
}
}
private void ReceiveTopicMessages(CancellationTokenSource cancellationSource,
OnMessagesReceived onMessagesReceived)
{
var needPeek = true;
long sequenceNumber = 0;
IEnumerable <BrokeredMessage> brokeredMessages = null;
#region peek messages that not been consumed since last time
while (!cancellationSource.IsCancellationRequested && needPeek)
{
try
{
brokeredMessages = _subscriptionClient.PeekBatch(sequenceNumber, 50);
if (brokeredMessages == null || brokeredMessages.Count() == 0)
{
break;
}
var messageContexts = new List <IMessageContext>();
foreach (var message in brokeredMessages)
{
if (message.State != MessageState.Deferred)
{
needPeek = false;
break;
}
messageContexts.Add(new MessageContext(message));
sequenceNumber = message.SequenceNumber + 1;
}
onMessagesReceived(messageContexts.ToArray());
}
catch (OperationCanceledException)
{
return;
}
catch (ThreadAbortException)
{
return;
}
catch (Exception ex)
{
Thread.Sleep(1000);
_logger.Error($"subscriptionClient.ReceiveBatch {_subscriptionClient.Name} failed", ex);
}
}
#endregion
#region receive messages to enqueue consuming queue
while (!cancellationSource.IsCancellationRequested)
{
try
{
brokeredMessages =
_subscriptionClient.ReceiveBatch(50,
Configuration.Instance.GetMessageQueueReceiveMessageTimeout());
foreach (var message in brokeredMessages)
{
message.Defer();
onMessagesReceived(new MessageContext(message));
}
}
catch (OperationCanceledException)
{
return;
}
catch (ThreadAbortException)
{
return;
}
catch (Exception ex)
{
Thread.Sleep(1000);
_logger.Error($"subscriptionClient.ReceiveBatch {_subscriptionClient.Name} failed", ex);
}
}
#endregion
}
public static async void Run(TimerInfo rewardsResponseTimer, ICollector <string> errormessage, TraceWriter log)
{
log.Verbose($"C# timer function processed a request.", "JE.RMS.Services.ScheduledReadRewardsRequestRecieved");
try
{
//Service bus queue names and connection stringsAllFulfillmentResponseSubscription
var connectionString = ConfigurationManager.AppSettings["MyServiceBusReader"].ToString();
SubscriptionClient AllFulfillmentResponseSubscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, "fulfillmentresponse", "AllFulfillmentResponseSubscription");
var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
int BatchSize = Convert.ToInt32(ConfigurationManager.AppSettings["RewardFulfillmentResponseBatchSize"]);
IEnumerable <BrokeredMessage> RecievedMessage = null;
long MessageCount = namespaceManager.GetSubscription("fulfillmentresponse", "AllFulfillmentResponseSubscription").MessageCount;
if (MessageCount > 0)
{
RecievedMessage = AllFulfillmentResponseSubscriptionClient.ReceiveBatch(BatchSize);
}
log.Verbose($"After the reading of queue message = {MessageCount}", "JE.RMS.Services.ScheduledReadRewardsRequestRecieved");
List <Guid> messageLockTokenList = new List <System.Guid>();
if (RecievedMessage != null && RecievedMessage.Count() > 0)
{
foreach (BrokeredMessage message in RecievedMessage)
{
var responsemessage = message.GetBody <FulfillmentResponse>();
//var responsemessage = JsonConvert.DeserializeObject<FulfillmentResponse>(raw);
log.Verbose($"C# trigger queue function processed a request. inputmessage={responsemessage}", "JE.RMS.Services.OnRewardsResponseRecieved");
#region Update Audit Fields
//Update timestapm in Audit fields
List <SqlParameter> AuditParam = new List <SqlParameter>();
AuditParam.Add(new SqlParameter("@RMSRewardID", responsemessage.RMSRewardID));
var RMSRewardID = MSSQLConnection.ExecuteStoredProcedure <string>(USPContstants.UpdateAuditFieldsInRewardsTrx, AuditParam);
log.Verbose($"FulfillmentResponseTimestamp updated successfully. RMSRewardID={RMSRewardID[0]}", "JE.RMS.Services.OnRewardsResponseRecieved");
string RewardTrxStatus = "Fulfillment completed";
if (responsemessage.Status == "Fail")
{
RewardTrxStatus = "Error";
}
List <SqlParameter> MessageLogParams = new List <SqlParameter>();
MessageLogParams.Add(new SqlParameter("@RMSRewardID", responsemessage.RMSRewardID));
MessageLogParams.Add(new SqlParameter("@MessageType", MessageType.RewardFulfillmentResponse.GetDescription()));
MessageLogParams.Add(new SqlParameter("@IPAddress", responsemessage.ClientIP));
MessageLogParams.Add(new SqlParameter("@Message", JsonConvert.SerializeObject(responsemessage)));
MessageLogParams.Add(new SqlParameter("@RewardsTrxID", null));
var ErrorMessageLogID = MSSQLConnection.ExecuteStoredProcedure <long>(USPContstants.SaveMessageLog, MessageLogParams);
log.Verbose($"MessageLog stored successfully. MessageLogID={ErrorMessageLogID[0]}", "JE.RMS.Services.ProcessFulfillmentForEnergyEarth");
////Call stored procedure to Save RewardTrxChangeLog
List <SqlParameter> RewardTrxChangeLogParams = new List <SqlParameter>();
RewardTrxChangeLogParams.Add(new SqlParameter("@RMSRewardID", responsemessage.RMSRewardID));
RewardTrxChangeLogParams.Add(new SqlParameter("@RewardTrxStatus", RewardTrxStatus));
RewardTrxChangeLogParams.Add(new SqlParameter("@Comment", string.Empty));
RewardTrxChangeLogParams.Add(new SqlParameter("@RewardsTrxID", null));
var RewardTrxChangeLogID = MSSQLConnection.ExecuteStoredProcedure <long>(USPContstants.SaveRewardTrxChangeLog, RewardTrxChangeLogParams);
log.Verbose($"RewardTrxChangeLog stored successfully. RewardTrxChangeLogID={RewardTrxChangeLogID[0]}", "JE.RMS.Services.OnRewardsResponseRecieved");
#endregion
messageLockTokenList.Add(message.LockToken);
}
AllFulfillmentResponseSubscriptionClient.CompleteBatch(messageLockTokenList);
}
}
catch (Exception ex)
{
log.Error($"Exception ={ex}", ex, "JE.RMS.Services.OnRewardsRequestRecieved");
errormessage.Add(JsonConvert.SerializeObject(ex).ToString());
}
}
public static RewardFulfillmentResponseList GetMessagesFromSubscription(long FulfillmentChannelID, RewardFulfillmentResponseList resp, TraceWriter log)
{
IEnumerable <BrokeredMessage> RecievedMessage = null;
long MessageCount = 0;
if (resp.RewardFulfillmentRequest == null)
{
resp.RewardFulfillmentRequest = new List <RewardFulfillmentRequest>();
}
BatchSize = BatchSize - resp.RewardFulfillmentRequest.Count;
if (FulfillmentChannelID == (int)Common.Constants.FulfillmentChannel.GBASSTariff)
{
MessageCount = namespaceManager.GetSubscription("fulfillmentrequest", "GBASSTariffSubscription").MessageCount;
if (MessageCount > 0)
{
RecievedMessage = GBASSTariffSubscription.ReceiveBatch(BatchSize, new TimeSpan(0, 0, 0));
}
}
else if (FulfillmentChannelID == (int)Common.Constants.FulfillmentChannel.GBASSCTLAdj)
{
MessageCount = namespaceManager.GetSubscription("fulfillmentrequest", "GBASSCTLAdjSubscription").MessageCount;
if (MessageCount > 0)
{
RecievedMessage = GBASSCTLAdjSubscription.ReceiveBatch(BatchSize, new TimeSpan(0, 0, 0));
}
}
else if (FulfillmentChannelID == (int)Common.Constants.FulfillmentChannel.Cheque)
{
MessageCount = namespaceManager.GetSubscription("fulfillmentrequest", "SmartConnectSubscription").MessageCount;
if (MessageCount > 0)
{
RecievedMessage = SmartConnectSubscriptionClient.ReceiveBatch(BatchSize, new TimeSpan(0, 0, 0));
}
}
List <Guid> messageLockTokenList = new List <System.Guid>();
resp.HasMoreMessages = false;
if (RecievedMessage != null && RecievedMessage.Count() > 0)
{
foreach (BrokeredMessage message in RecievedMessage)
{
var raw = message.GetBody <string>();
var RewardFulfillmentRequestObj = JsonConvert.DeserializeObject <RewardFulfillmentRequestList>(raw);
string RMSRewardID = RewardFulfillmentRequestObj.RewardFulfillmentRequest.RMSRewardID;
////Call stored procedure to Update RewardTrx
List <SqlParameter> RewardTrxParams = new List <SqlParameter>();
RewardTrxParams.Add(new SqlParameter("@RMSRewardID", RMSRewardID));
var UpdatedRewardTrxID = MSSQLConnection.ExecuteStoredProcedure <long>(USPContstants.UpdateProcessFulfillmentTimestamp, RewardTrxParams).FirstOrDefault();
log.Verbose($"RewardTrx updated successfully. RewardTrID={UpdatedRewardTrxID}", "JE.RMS.Services.GetRewardFulfillmentRequest");
resp.RewardFulfillmentRequest.Add(RewardFulfillmentRequestObj.RewardFulfillmentRequest);
messageLockTokenList.Add(message.LockToken);
}
if (FulfillmentChannelID == (int)Common.Constants.FulfillmentChannel.GBASSTariff)
{
GBASSTariffSubscription.CompleteBatch(messageLockTokenList);
}
else if (FulfillmentChannelID == (int)Common.Constants.FulfillmentChannel.GBASSCTLAdj)
{
GBASSCTLAdjSubscription.CompleteBatch(messageLockTokenList);
}
else if (FulfillmentChannelID == (int)Common.Constants.FulfillmentChannel.Cheque)
{
SmartConnectSubscriptionClient.CompleteBatch(messageLockTokenList);
}
}
resp.HasMoreMessages = MessageCount > resp.RewardFulfillmentRequest.Count ? true : false;
if (resp.HasMoreMessages && resp.RewardFulfillmentRequest.Count < RepeatCallSize)
{
GetMessagesFromSubscription(FulfillmentChannelID, resp, log);
}
resp.TotalRecord = MessageCount;
return(resp);
}
