public static IPipelineChannelOutgoing <P> AddChannelOutgoing <P>(this P pipeline
, string channelId
, string description = null
, IEnumerable <SenderPartitionConfig> partitions = null
, bool?boundaryLoggingEnabled = null
, bool internalOnly = false
, Action <IPipelineChannelOutgoing <P>, Channel> assign = null
, bool autosetPartition01 = true
)
where P : IPipeline
{
var channel = pipeline.ToMicroservice().Communication.RegisterChannel(
new Channel(channelId, ChannelDirection.Outgoing, description, boundaryLoggingEnabled, internalOnly));
if (partitions == null && autosetPartition01)
{
partitions = SenderPartitionConfig.Init(0, 1);
}
channel.Partitions = partitions?.ToList();
var cpipe = new ChannelPipelineOutgoing <P>(pipeline, channel);
assign?.Invoke(cpipe, cpipe.Channel);
return(cpipe);
}
/// <summary>
/// This is the default constructor for the Azure service bus sender.
/// </summary>
public QueueEventSource() : base()
{
mJsonSerializer = new JsonSerializer {
TypeNameHandling = TypeNameHandling.Auto
};
PriorityPartitions = SenderPartitionConfig.Init(1).ToList();
}
//Outgoing
public static C AttachPriorityPartition <C>(this C pipeline
, SenderPartitionConfig config)
where C : IPipelineChannelOutgoing <IPipeline>
{
AttachPriorityPartition <SenderPartitionConfig>(pipeline, config);
return(pipeline);
}
/// <summary>
/// This method creates the client.
/// </summary>
/// <param name="partition">The sender partitions.</param>
/// <returns>Returns the client holder.</returns>
protected override TcpTlsClientHolder ClientCreate(SenderPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Type = "TcpTls Sender";
client.Name = partition.Priority.ToString();
return(client);
}
/// <summary>
/// This is the default client create logic for the manual sender.
/// </summary>
/// <param name="partition">The partition collection.</param>
/// <returns>
/// Returns the client.
/// </returns>
protected override ManualChannelClientHolder ClientCreate(SenderPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Name = mPriorityClientNamer(ChannelId, partition.Priority);
client.IncomingAction = ProcessInvoke;
return(client);
}
/// <summary>
/// This is the default client create logic.
/// </summary>
/// <param name="partition"></param>
/// <returns>
/// Returns the client.
/// </returns>
protected override UdpClientHolder ClientCreate(SenderPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.ContentType = ContentType;
client.ContentEncoding = ContentEncoding;
client.Start = () =>
{
client.Client = client.ClientCreate();
client.IsActive = true;
};
client.ClientCreate = () =>
{
var c = new UdpHelper(Config, UdpHelperMode.Sender);
c.Start();
return(c);
};
client.ClientClose = () => client.Client.Stop();
client.MessagePack = (p) =>
{
var holder = p.Message.Blob;
if (holder.ContentType == null)
{
holder.ContentType = ContentType;
}
if (holder.ContentEncoding == null)
{
holder.ContentEncoding = ContentEncoding;
}
if (!PayloadSerializer.TryPayloadSerialize(holder))
{
throw new ArgumentException("Cannot serialize.");
}
if (holder.Blob.Length > UdpMessageMaximumPayloadSize)
{
//throw new
}
return(holder);
};
return(client);
}
/// <summary>
/// This is the default client create logic.
/// </summary>
/// <param name="partition">The specific partition to create the client.</param>
/// <returns>
/// Returns the client.
/// </returns>
protected override AzureClientHolder <C, M> ClientCreate(SenderPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Start = () =>
{
client.Client = client.ClientCreate();
client.IsActive = true;
};
client.ClientClose = () => 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 is the default constructor for the Azure service bus sender.
/// </summary>
public AzureSBEventHubSender() : base()
{
SenderPriorityPartitions = SenderPartitionConfig.Init(1).ToList();
}
protected override AzureClientHolder <EventHubClient, EventData> ClientCreate(SenderPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.MessagePack = PackEventSource;
return(client);
}
public static ChannelPipelineOutgoing AssignPriorityPartition(this ChannelPipelineOutgoing pipeline, params int[] init)
{
SenderPartitionConfig.Init(init).ForEach((p) => AddPriorityPartition <SenderPartitionConfig>(pipeline, p));
return(pipeline);
}
/// <summary>
/// This override sets the transmit options for the client.
/// </summary>
/// <returns>Returns the client.</returns>
protected override AzureClientHolder <QueueClient, Microsoft.Azure.ServiceBus.Message> ClientCreate(SenderPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Type = "Queue Sender";
client.Name = mPriorityClientNamer(EntityName ?? ChannelId, partition.Priority);
client.AssignMessageHelpers();
//client.FabricInitialize = () => Connection.QueueFabricInitialize(client.Name);
//Set the method that creates the client.
client.ClientCreate = () =>
{
return(new QueueClient(Connection.Connection.ToString(), client.Name, Connection.DefaultReceiveMode, Connection.DefaultRetryPolicy));
};
//We have to do this due to the stupid inheritance rules for Azure Service Bus.
client.MessageTransmit = async(b) => await client.Client.SendAsync(b);
return(client);
}
protected override AzureClientHolder <TopicClient, BrokeredMessage> ClientCreate(SenderPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Type = "Topic Sender";
client.Name = mPriorityClientNamer(AzureConn.ConnectionName, partition.Priority);
client.AssignMessageHelpers();
client.FabricInitialize = () => AzureConn.TopicFabricInitialize(client.Name);
client.ClientCreate = () => TopicClient.CreateFromConnectionString(AzureConn.ConnectionString, client.Name);
client.MessageTransmit = async(b) => await client.Client.SendAsync(b);
return(client);
}
//Outgoing
public static ChannelPipelineOutgoing AssignPriorityPartition(this ChannelPipelineOutgoing pipeline, SenderPartitionConfig config)
{
AddPriorityPartition <SenderPartitionConfig>(pipeline, config);
return(pipeline);
}
/// <summary>
/// This is the default client create logic.
/// </summary>
/// <param name="partition">The specific partition to create the client.</param>
/// <returns>
/// Returns the client.
/// </returns>
protected override AzureClientHolder <TopicClient, Microsoft.Azure.ServiceBus.Message> ClientCreate(SenderPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Type = "Topic Sender";
client.Name = mPriorityClientNamer(EntityName ?? ChannelId, partition.Priority);
client.AssignMessageHelpers();
//client.FabricInitialize = () => Connection.TopicFabricInitialize(client.Name);
//client.ClientCreate = () => TopicClient.CreateFromConnectionString(Connection.ConnectionString, client.Name);
client.MessageTransmit = async(b) => await client.Client.SendAsync(b);
return(client);
}
/// <summary>
/// This override sets the transmit options for the client.
/// </summary>
/// <returns>Returns the client.</returns>
protected override AzureClientHolder <QueueClient, BrokeredMessage> ClientCreate(SenderPartitionConfig partition)
{
var client = base.ClientCreate(partition);
client.Type = "Queue Sender";
client.Name = mPriorityClientNamer(AzureConn.ConnectionName, partition.Priority);
client.AssignMessageHelpers();
client.FabricInitialize = () => AzureConn.QueueFabricInitialize(client.Name);
//Set the method that creates the client.
client.ClientCreate = () => QueueClient.CreateFromConnectionString(AzureConn.ConnectionString, client.Name);
//We have to do this due to the stupid inheritance rules for Azure Service Bus.
client.MessageTransmit = async(b) => await client.Client.SendAsync(b);
return(client);
}
