/// <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); }