public static async Task Run([ServiceBusTrigger(
"<your_queue_name>",
Connection = "QueueConnectionString")]
byte[] item,
Int32 deliveryCount,
DateTime enqueuedTimeUtc,
string messageId,
IDictionary <string, object> UserProperties,
FunctionContext context)
{
var logger = context.GetLogger("ServiceBusFunction");
logger.LogInformation($"MessageID: {messageId}");
FunctionInputData functionInputData = new FunctionInputData(item, messageId, UserProperties);
var settings =
new StorageSettingData(
"<your_blob_storage_container_name>",
"<your_blob_storage_connection_string>",
VeryLargeMessageStrategy.Storage);
FunctionMessageReader reader = new FunctionMessageReader(settings);
await reader.SubScribe(functionInputData,
(arg) =>
{
//PUT HERE YOUR MESSAGE HANDLING LOGIC
logger.LogInformation($"function processed object: {arg.ReceivedEventMessage?.ObjectName??arg.ReceivedEventMessage.Body.Substring(0,10)}");
});
return;
}
public static void Run([ServiceBusTrigger(
"<your_queue_name>",
Connection = "QueueConnectionString")]
byte[] item,
Int32 deliveryCount,
DateTime enqueuedTimeUtc,
string messageId,
IDictionary <string, object> UserProperties,
ILogger log)
//Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message , ILogger log)
{
log.LogInformation($"C# ServiceBus queue trigger function processed message: {messageId}");
FunctionInputData functionInputData = new FunctionInputData(item, messageId, UserProperties);
var settings =
new StorageSettingData(
"<your_blob_storage_container_name>",
"<your_blob_storage_connection_string>",
VeryLargeMessageStrategy.Storage);
FunctionMessageReader reader = new FunctionMessageReader(settings);
reader.SubScribe(functionInputData,
(arg) =>
{
//PUT HERE YOUR MESSAGE HANDLING LOGIC
log.LogInformation($"function processed object: {arg.ReceivedEventMessage?.ObjectName ?? arg.ReceivedEventMessage.Body.Substring(0, 10) }");
}
);
}
/// <summary>
/// Subscribe an action for reading message from queue or topic with Azure Function
/// </summary>
/// <param name="functionData">Object hold infomration retrived by input binding of function</param>
/// <param name="onMessageReceived">Action invoked when a message arrive</param>
/// <returns></returns>
public async Task SubScribe(FunctionInputData functionData, Action <MessageReceivedEventArgs> onMessageReceived)
{
OnMessageReceived = onMessageReceived;
CancellationToken token = new CancellationToken();
await MessageReceivedHandler(functionData, token);
}
/// <summary>
/// Get message from the storage
/// </summary>
/// <param name="functionInputData">Function inputbinding data</param>
/// <param name="storage">Object to handle stored data</param>
/// <returns>Event message</returns>
internal static async Task<EventMessage> GetStoredMessage(FunctionInputData functionInputData, MessageStorage storage, Type typeToDeserialize, IMessageDeserializer messagedeserializer)
{
var bytes = storage.DownloadMessage(functionInputData.MessageId);
var jsonMessageString = await bytes.Unzip() as string;
var message = JsonConvert.DeserializeObject<EventMessage>(jsonMessageString);
GetObjectFromMessage(message, typeToDeserialize, messagedeserializer);
return message;
}
/// <summary>
/// Get the message from compressed state
/// </summary>
/// <param name="functionInputData">Function inputbinding data</param>
/// <returns>Uncompressed message</returns>
internal static async Task<EventMessage> GetZippedMessage(FunctionInputData functionInputData, Type typeToDeserialize, IMessageDeserializer messagedeserializer)
{
var bytes = Convert.FromBase64String(System.Text.Encoding.UTF8.GetString(functionInputData.ByteArrayMessage));
//var bytes = Convert.FromBase64String(messageBody);
//var bytes = functionInputData.ByteArrayMessage;
var jsonMessageString = await bytes.Unzip() as string;
var message = JsonConvert.DeserializeObject<EventMessage>(jsonMessageString);
GetObjectFromMessage(message, typeToDeserialize, messagedeserializer);
return message;
}
/// <summary>
/// Subscribe an action for reading message from queue or topic with Azure Function
/// </summary>
/// <param name="functionData">Object hold infomration retrived by input binding of function</param>
/// <param name="onMessageReceived">Action invoked when a message arrive</param>
/// <param name="token">CanellationToken</param>
/// <returns></returns>
public async Task SubScribe(FunctionInputData functionData, Action <MessageReceivedEventArgs> onMessageReceived, CancellationToken token)
{
//try
//{
OnMessageReceived = onMessageReceived;
await MessageReceivedHandler(functionData, token);
//}
//catch
//{
//}
}
/// <summary>
/// Handle the received message
/// </summary>
/// <param name="functionInputData">Data from the message by inpudbinding arguments</param>
/// <param name="token">CanellationToken</param>
/// <returns></returns>
virtual protected async Task MessageReceivedHandler(FunctionInputData functionInputData, CancellationToken token)
{
try
{
// Process message from subscription.
if (functionInputData.UserProperties.ContainsKey(MessageFactory.MessageModePropertyName))
{
var prop = functionInputData.UserProperties[MessageFactory.MessageModePropertyName];
string propName = Convert.ToString(prop);
if (!string.IsNullOrEmpty(propName))
{
MessageModes messageMode;
bool parsed = Enum.TryParse(propName, out messageMode);
if (parsed)
{
EventMessage msg = null;
switch (messageMode)
{
case MessageModes.Simple:
msg = ReaderHandler.GetSimpleMessage(functionInputData.ByteArrayMessage, TypeToDeserialize, MessageDeserializer);
MessageReceived(msg, functionInputData);
break;
case MessageModes.GZip:
msg = await ReaderHandler.GetZippedMessage(functionInputData, TypeToDeserialize, MessageDeserializer);
MessageReceived(msg, functionInputData);
break;
case MessageModes.Chunk:
msg = await ReaderHandler.GetChunkedMessage(functionInputData, ChunkDictionary, TypeToDeserialize, MessageDeserializer);
if (msg != null)
{
MessageReceived(msg, functionInputData);
}
break;
case MessageModes.Storage:
msg = await ReaderHandler.GetStoredMessage(functionInputData, Storage, TypeToDeserialize, MessageDeserializer);
MessageReceived(msg, functionInputData);
break;
default:
break;
}
}
}
}
}
catch
{
throw;
}
}
/// <summary>
/// Get the message by chunks
/// </summary>
/// <param name="functionInputData">Function inputbinding data</param>
/// <param name="chunkDictionary">chunk data</param>
/// <returns>If chunks are completed return the recomposed completed message</returns>
internal static async Task<EventMessage> GetChunkedMessage(FunctionInputData functionInputData, ConcurrentDictionary<string, List<byte[]>> chunkDictionary, Type typeToDeserialize, IMessageDeserializer messagedeserializer)
{
object chunkGroupIdObject = functionInputData.UserProperties[MessageFactory.MessageChunkGroupIdPropertyName];
int? chunkIndex = functionInputData.UserProperties[MessageFactory.MessageChunkIndex] as int?;
string chunkGroupIdString = Convert.ToString(chunkGroupIdObject);
byte[] bytes = Convert.FromBase64String(System.Text.Encoding.UTF8.GetString(functionInputData.ByteArrayMessage));
List<byte[]> newBytes = new List<byte[]>();
newBytes.Add(bytes);
chunkDictionary.AddOrUpdate(chunkGroupIdString, newBytes, (key, currentList) =>
{
currentList.Insert(chunkIndex.Value, bytes);
return currentList;
}
);
var chunkState = functionInputData.UserProperties[MessageFactory.MessageChunkStatePropertyName];
string chunkStateString = Convert.ToString(chunkState);
ChunkStates currentChunkState;
bool parsedState = Enum.TryParse(chunkStateString, out currentChunkState);
EventMessage ret = null;
if (parsedState && currentChunkState == ChunkStates.End)
{
byte[] completeMessage = new byte[0];
List<byte[]> chunks = chunkDictionary[chunkGroupIdString];
foreach (var chunk in chunks)
{
var tmp = completeMessage.Concat(chunk);
completeMessage = tmp.ToArray();
}
var jsonMessageString = await completeMessage.Unzip() as string;
var message = JsonConvert.DeserializeObject<EventMessage>(jsonMessageString);
GetObjectFromMessage(message, typeToDeserialize, messagedeserializer);
ret = message;
}
return ret;
}
public void Run([ServiceBusTrigger("sbq-testunitmessage", Connection = "QueueConnectionString")] byte[] item,
string messageId,
IDictionary <string, object> UserProperties)
{
_logger.LogInformation($"C# ServiceBus queue trigger function processed message: {messageId}");
FunctionInputData functionInputData = new FunctionInputData(item, messageId, UserProperties);
var settings =
new StorageSettingData(
"<your storage container name>",
"<blob storage connection string>",
VeryLargeMessageStrategy.Storage);
FunctionMessageReader reader = new FunctionMessageReader(settings);
reader.SubScribe(functionInputData,
(arg) =>
{
//PUT HERE YOUR MESSAGE HANDLING LOGIC
_logger.LogInformation($"function processed object: {arg.ReceivedEventMessage?.ObjectName ?? arg.ReceivedEventMessage.Body.Substring(0, 10) }");
}
);
}
/// <summary>
/// Initialize with arguments
/// </summary>
/// <param name="message">Message received</param>
/// <param name="functionInputData">InputBinding function arguments</param>
public MessageReceivedEventArgs(EventMessage message, FunctionInputData functionInputData)
: this(message, (ServiceBusReceivedMessage)null)
{
ReceivedByteArrayMessage = functionInputData?.ByteArrayMessage;
}
/// <summary>
/// Initialize with arguments
/// </summary>
/// <param name="message">Message received</param>
/// <param name="receivedMessage">Original service bus message</param>
/// <param name="functionInputData">InputBinding function arguments</param>
public MessageReceivedEventArgs(EventMessage message, Message receivedMessage, FunctionInputData functionInputData)
: this(message, receivedMessage)
{
ReceivedByteArrayMessage = functionInputData?.ByteArrayMessage;
}
/// <summary>
/// Raise OnMessageReceived event
/// </summary>
/// <param name="message">Message managed by this library</param>
/// <param name="functionInputData">Data from the message by inpudbinding arguments</param>
private void MessageReceived(EventMessage message, FunctionInputData functionInputData)
{
OnMessageReceived?.Invoke(new MessageReceivedEventArgs(message, functionInputData));
}
