/// <summary>
/// This override sets the default processing time to the client for incoming messages.
/// </summary>
/// <returns>Returns the new client.</returns>
protected override H ClientCreate(ListenerPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.MessageMaxProcessingTime = partition.PayloadMaxProcessingTime;
client.FabricMaxMessageLock = partition.FabricMaxMessageLock;
client.MappingChannelId = MappingChannelId;
client.SupportsRateLimiting = partition.SupportsRateLimiting;
client.Weighting = partition.PriorityWeighting;
client.Start = () =>
{
client.Client = client.ClientCreate();
client.IsActive = true;
};
client.Stop = () =>
{
client.IsActive = false;
client.ClientClose();
};
return(client);
}
//Incoming
public static C AttachPriorityPartition <C>(this C pipeline
, ListenerPartitionConfig config)
where C : IPipelineChannelIncoming <IPipeline>
{
AttachPriorityPartition <ListenerPartitionConfig>(pipeline, config);
return(pipeline);
}
/// <summary>
/// Use this pipeline command to add a channel to a Microservice.
/// </summary>
/// <param name="pipeline">The pipeline.</param>
/// <param name="channelId">The channel id.</param>
/// <param name="description">A description of what the channel is used for.</param>
/// <param name="partitions">The supported partition levels for the channel. If null, this will be set to Priority 0 and 1.</param>
/// <param name="boundaryLoggingEnabled">Use this flag to override the default boundary logging settings for the Microservice.</param>
/// <param name="resourceProfiles">The resource profiles that should be used in the polling logic to reduce or stop incoming messages.</param>
/// <param name="internalOnly">Set this flag to true if you don't wish to attach any external listeners to this channel, i.e. internal only.</param>
/// <param name="assign"></param>
/// <param name="autosetPartition01">This method automatically sets the default priority 0 and 1 partitions for the channel.</param>
/// <returns>The original pipeline.</returns>
public static IPipelineChannelIncoming <P> AddChannelIncoming <P>(this P pipeline
, string channelId
, string description = null
, IEnumerable <ListenerPartitionConfig> partitions = null
, bool?boundaryLoggingEnabled = null
, IEnumerable <ResourceProfile> resourceProfiles = null
, bool internalOnly = false
, Action <IPipelineChannelIncoming <P>, Channel> assign = null
, bool autosetPartition01 = true
)
where P : IPipeline
{
var channel = pipeline.ToMicroservice().Communication.RegisterChannel(
new Channel(channelId, ChannelDirection.Incoming, description, boundaryLoggingEnabled, internalOnly));
if (partitions == null && autosetPartition01)
{
partitions = ListenerPartitionConfig.Init(0, 1);
}
channel.Partitions = partitions?.ToList();
if (resourceProfiles != null)
{
channel.ResourceProfiles = resourceProfiles?.ToList();
}
var cpipe = new ChannelPipelineIncoming <P>(pipeline, channel);
assign?.Invoke(cpipe, cpipe.Channel);
return(cpipe);
}
/// <summary>
/// This override creates the client and registers/unregisters it with the protocol.
/// </summary>
/// <param name="partition">The partition to create the client for.</param>
/// <returns>Returns the client holder.</returns>
protected override TcpTlsClientHolder ClientCreate(ListenerPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Type = "TcpTls Listener";
client.Name = $"Channel{partition.Priority}";
//TODO: client.ClientCreate = () => new TcpTlsClient();
return(client);
}
protected override ManualChannelClientHolder ClientCreate(ListenerPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Name = mPriorityClientNamer(ChannelId, partition.Priority);
client.ClientCreate = () => new ManualChannelConnection();
client.ClientClose = () => { };
return(client);
}
/// <summary>
/// This method sets the start and stop listener methods.
/// </summary>
/// <returns>The client.</returns>
protected override AzureClientHolder <C, M> ClientCreate(ListenerPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.ClientClose = () =>
{
if (client.Client != null)
{
client.Client.CloseAsync().Wait();
}
};
return(client);
}
public static C AttachPriorityPartition <C>(this C pipeline, params int[] init)
where C : IPipelineChannel
{
if (pipeline is IPipelineChannelIncoming)
{
ListenerPartitionConfig.Init(init).ForEach((p) => AttachPriorityPartition <ListenerPartitionConfig>(pipeline, p));
}
else if (pipeline is IPipelineChannelOutgoing)
{
SenderPartitionConfig.Init(init).ForEach((p) => AttachPriorityPartition <SenderPartitionConfig>(pipeline, p));
}
else
{
throw new ArgumentOutOfRangeException("AttachPriorityPartition unexpected partition type.");
}
return(pipeline);
}
/// <summary>
/// use this command to add a channel to a Microservice.
/// </summary>
/// <param name="pipeline">The pipeline.</param>
/// <param name="channelId">The channel id.</param>
/// <param name="description"></param>
/// <param name="partitions"></param>
/// <param name="boundaryLoggingEnabled"></param>
/// <param name="resourceProfiles"></param>
/// <param name="internalOnly"></param>
/// <param name="assign"></param>
/// <param name="autosetPartition01">This method automatically sets the default priority 0 and 1 partitions for the channel.</param>
/// <returns>The original pipeline.</returns>
public static IPipelineChannelBroadcast <P> AddChannelBroadcast <P>(this P pipeline
, string channelId
, string description = null
, IEnumerable <ListenerPartitionConfig> partitionsListener = null
, IEnumerable <SenderPartitionConfig> partitionsSender = null
, bool?boundaryLoggingEnabled = null
, IEnumerable <ResourceProfile> resourceProfiles = null
, bool internalOnly = false
, Action <IPipelineChannelBroadcast <P> > assign = null
, bool autosetPartition2 = true
)
where P : IPipeline
{
var channelListener = pipeline.ToMicroservice().Communication.RegisterChannel(
new Channel(channelId, ChannelDirection.Incoming, description, boundaryLoggingEnabled, internalOnly));
var channelSender = pipeline.ToMicroservice().Communication.RegisterChannel(
new Channel(channelId, ChannelDirection.Outgoing, description, boundaryLoggingEnabled, internalOnly));
if (partitionsListener == null && autosetPartition2)
{
partitionsListener = ListenerPartitionConfig.Init(2);
}
if (partitionsSender == null && autosetPartition2)
{
partitionsSender = SenderPartitionConfig.Init(2);
}
channelListener.Partitions = partitionsListener?.ToList();
channelSender.Partitions = partitionsSender?.ToList();
if (resourceProfiles != null)
{
channelListener.ResourceProfiles = resourceProfiles?.ToList();
}
var cpipe = new ChannelPipelineBroadcast <P>(pipeline, channelListener, channelSender);
assign?.Invoke(cpipe);
return(cpipe);
}
/// <summary>
/// This override sets the default processing time to the client for incoming messages.
/// </summary>
/// <param name="partition">The listener partition.</param>
/// <returns>
/// Returns the new client.
/// </returns>
protected override ManualChannelClientHolder ClientCreate(ListenerPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Name = mPriorityClientNamer(ChannelId, partition.Priority);
client.ClientCreate = () =>
{
var queue = Fabric.CreateQueueClient(client.Name);
return(queue);
};
//client.SupportsQueueLength = true;
//client.QueueLength => return Fabric.
client.ClientClose = () => client.Purge();
return(client);
}
/// <summary>
/// This override sets the default processing time to the client for incoming messages.
/// </summary>
/// <param name="partition">The current partition.</param>
/// <returns>
/// Returns the new client.
/// </returns>
protected override UdpClientHolder ClientCreate(ListenerPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.ContentType = ContentType;
client.ContentEncoding = ContentEncoding;
client.ClientCreate = () =>
{
var c = new UdpHelper(Config, UdpHelperMode.Listener);
c.Start();
return(c);
};
client.ClientClose = () => client.Client.Stop();
client.MessageUnpack = (holder) =>
{
if (!PayloadSerializer.TryPayloadDeserialize(holder))
{
holder.SetObject(new UdpHelper.Message {
Buffer = holder.Blob, RemoteEndPoint = (IPEndPoint)holder.Metadata
});
}
var sMessage = new ServiceMessage((client.MappingChannelId ?? client.ChannelId, RequestAddress), ResponseAddress);
if (ResponseAddress != null)
{
sMessage.ResponseChannelPriority = ResponseAddressPriority;
}
sMessage.ChannelPriority = RequestAddressPriority ?? client.Priority;
sMessage.Blob = holder;
return(sMessage);
};
return(client);
}
/// <summary>
/// This override sets the receive options for the client.
/// </summary>
/// <returns>Returns the client.</returns>
protected override AzureClientHolder <QueueClient, BrokeredMessage> ClientCreate(ListenerPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Type = "Queue Listener";
client.Name = mPriorityClientNamer(AzureConn.ConnectionName, partition.Priority);
client.AssignMessageHelpers();
client.FabricInitialize = () =>
{
var queuedesc = AzureConn.QueueFabricInitialize(client.Name, lockDuration: partition.FabricMaxMessageLock);
};
client.SupportsQueueLength = true;
client.QueueLength = () =>
{
try
{
var desc = AzureConn.NamespaceManager.GetQueue(client.Name);
client.QueueLengthLastPoll = DateTime.UtcNow;
if (IsDeadLetterListener)
{
return(desc.MessageCountDetails.DeadLetterMessageCount);
}
else
{
return(desc.MessageCountDetails.ActiveMessageCount);
}
}
catch (Exception)
{
return(null);
}
};
client.ClientCreate = () =>
{
var messagingFactory = MessagingFactory.CreateFromConnectionString(AzureConn.ConnectionString);
string queueName = IsDeadLetterListener ? QueueClient.FormatDeadLetterPath(client.Name) : client.Name;
var queue = messagingFactory.CreateQueueClient(queueName);
return(queue);
};
client.MessageReceive = async(c, t) =>
{
return(await client.Client.ReceiveBatchAsync(c ?? 10, TimeSpan.FromMilliseconds(t ?? 500)));
};
return(client);
}
/// <summary>
/// This override sets the receive options for the client.
/// </summary>
/// <returns>Returns the client.</returns>
protected override AzureClientHolder <QueueClient, Microsoft.Azure.ServiceBus.Message> ClientCreate(ListenerPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Type = "Queue Listener";
client.Name = mPriorityClientNamer(EntityName ?? ChannelId, partition.Priority);
client.AssignMessageHelpers();
//client.FabricInitialize = () =>
//{
// var queuedesc = Connection.QueueFabricInitialize(client.Name, lockDuration: partition.FabricMaxMessageLock);
//};
client.SupportsQueueLength = false;
//client.QueueLength = () =>
//{
// try
// {
// var desc = Connection.NamespaceManager.GetQueue(client.Name);
// client.QueueLengthLastPoll = DateTime.UtcNow;
// if (IsDeadLetterListener)
// return desc.MessageCountDetails.DeadLetterMessageCount;
// else
// return desc.MessageCountDetails.ActiveMessageCount;
// }
// catch (Exception)
// {
// return null;
// }
//};
client.ClientCreate = () =>
{
string queueName = IsDeadLetterListener ? EntityNameHelper.FormatDeadLetterPath(client.Name) : client.Name;
var qClient = new QueueClient(Connection.Connection.ToString(), queueName, Connection.DefaultReceiveMode, Connection.DefaultRetryPolicy);
return(qClient);
};
//client.ClientCreate = () =>
//{
// var messagingFactory = MessagingFactory.CreateFromConnectionString(Connection.ConnectionString);
// string queueName = IsDeadLetterListener ? QueueClient.FormatDeadLetterPath(client.Name) : client.Name;
// var queue = messagingFactory.CreateQueueClient(queueName);
// return queue;
//};
//client.MessageReceive = async (c,t) =>
//{
// return await client.Client.ReceiveBatchAsync(c??10, TimeSpan.FromMilliseconds(t??500));
//};
return(client);
}
/// <summary>
/// This method creates the specific client.
/// </summary>
/// <returns>Returns the client.</returns>
protected override AzureClientHolder <SubscriptionClient, Microsoft.Azure.ServiceBus.Message> ClientCreate(ListenerPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Filters = GetFilters().Select((f) => f.SqlExpression).ToList();
client.Type = "Subscription Listener";
client.Name = mPriorityClientNamer(EntityName ?? ChannelId, partition.Priority);
client.AssignMessageHelpers();
//client.FabricInitialize = () =>
//{
// Connection.TopicFabricInitialize(client.Name);
// var subDesc = Connection.SubscriptionFabricInitialize(client.Name, mSubscriptionId
// , autoDeleteSubscription: DeleteOnIdleTime
// , lockDuration: partition.FabricMaxMessageLock);
//};
client.SupportsQueueLength = false;
//client.QueueLength = () =>
//{
// try
// {
// var desc = Connection.NamespaceManager.GetSubscription(client.Name, mSubscriptionId);
// client.QueueLengthLastPoll = DateTime.UtcNow;
// return desc.MessageCountDetails.ActiveMessageCount;
// }
// catch (Exception)
// {
// return null;
// }
//};
client.CanStart = GetFilters().Count > 0;
//client.ClientCreate = () =>
//{
// var messagingFactory = MessagingFactory.CreateFromConnectionString(Connection.ConnectionString);
// var subClient = messagingFactory.CreateSubscriptionClient(client.Name, mSubscriptionId);
// subClient.PrefetchCount = 50;
// subClient.RemoveRule("$default");
// SetFilters(subClient, client.Name, mSubscriptionId);
// return subClient;
//};
client.ClientRefresh = () =>
{
SetFilters(client.Client, client.Name, mSubscriptionId);
};
//client.MessageReceive = async (c,t) =>
//{
// var messages = await client.Client.ReceiveBatchAsync(c??10, TimeSpan.FromMilliseconds(t??500));
// return messages;
//};
return(client);
}
/// <summary>
/// This method creates the specific client.
/// </summary>
/// <returns>Returns the client.</returns>
protected override AzureClientHolder <SubscriptionClient, BrokeredMessage> ClientCreate(ListenerPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Filters = GetFilters().Select((f) => f.SqlExpression).ToList();
client.Type = "Subscription Listener";
client.Name = mPriorityClientNamer(AzureConn.ConnectionName, partition.Priority);
client.AssignMessageHelpers();
client.FabricInitialize = () =>
{
AzureConn.TopicFabricInitialize(client.Name);
var subDesc = AzureConn.SubscriptionFabricInitialize(client.Name, mSubscriptionId
, autoDeleteSubscription: DeleteOnIdleTime
, lockDuration: partition.FabricMaxMessageLock);
};
client.SupportsQueueLength = true;
client.QueueLength = () =>
{
try
{
var desc = AzureConn.NamespaceManager.GetSubscription(client.Name, mSubscriptionId);
client.QueueLengthLastPoll = DateTime.UtcNow;
return(desc.MessageCountDetails.ActiveMessageCount);
}
catch (Exception)
{
return(null);
}
};
client.CanStart = GetFilters().Count > 0;
client.ClientCreate = () =>
{
var messagingFactory = MessagingFactory.CreateFromConnectionString(AzureConn.ConnectionString);
var subClient = messagingFactory.CreateSubscriptionClient(client.Name, mSubscriptionId);
subClient.PrefetchCount = 50;
subClient.RemoveRule("$default");
SetFilters(subClient, client.Name, mSubscriptionId);
return(subClient);
};
client.ClientRefresh = () =>
{
SetFilters(client.Client, client.Name, mSubscriptionId);
};
client.MessageReceive = async(c, t) =>
{
var messages = await client.Client.ReceiveBatchAsync(c ?? 10, TimeSpan.FromMilliseconds(t ?? 500));
return(messages);
};
return(client);
}
public static ChannelPipelineIncoming AssignPriorityPartition(this ChannelPipelineIncoming pipeline, params int[] init)
{
ListenerPartitionConfig.Init(init).ForEach((p) => AddPriorityPartition <ListenerPartitionConfig>(pipeline, p));
return(pipeline);
}
//Incoming
public static ChannelPipelineIncoming AssignPriorityPartition(this ChannelPipelineIncoming pipeline, ListenerPartitionConfig config)
{
AddPriorityPartition <ListenerPartitionConfig>(pipeline, config);
return(pipeline);
}
