/// <summary>
        /// Convert HostOption & ExchangeOption & QueueOption to MessageQueueOption
        /// </summary>
        /// <param name="option"></param>
        /// <returns></returns>
        protected (HostOption, ExchangeOption, QueueOption) ConvertOption(MessageQueueOption option)
        {
            var hostOption = new HostOption
            {
                ClientName  = option.ClientName,
                Host        = option.Host,
                Port        = option.Port,
                VirtualHost = option.VirtualHost,
                UserName    = option.UserName,
                Password    = option.Password
            };

            var exchangeOption = new ExchangeOption
            {
                ExchangeName  = option.ExchangeName,
                ExchangeType  = option.ExchangeType,
                IsAutoDeleted = option.ExchangeAutoDelete,
                IsDurable     = option.ExchangeDurable,
                RoutingKey    = option.RoutingKey
            };

            var queueOption = new QueueOption
            {
                ConsumerTag   = option.CustomerTag,
                IsAutoDeleted = option.QueueAutoDelete,
                IsDurable     = option.QueueDurable,
                IsExclusive   = option.QueueExclusive,
                QueueName     = option.QueueName,
                AutoAck       = option.QueueAutoAck
            };

            return(hostOption, exchangeOption, queueOption);
        }
示例#2
0
        public void Start(MessageQueueOption option)
        {
            var hostOption = new HostOption
            {
                ClientName  = option.ClientName,
                Host        = option.Host,
                Port        = option.Port,
                VirtualHost = option.VirtualHost,
                UserName    = option.UserName,
                Password    = option.Password
            };

            var exchangeOption = new ExchangeOption
            {
                ExchangeName  = option.ExchangeName,
                ExchangeType  = option.ExchangeType,
                IsAutoDeleted = option.ExchangeAutoDelete,
                IsDurable     = option.ExchangeDurable,
                RoutingKey    = option.RoutingKey
            };

            var queueOption = new QueueOption
            {
                QueueName     = option.QueueName,
                IsDurable     = option.QueueDurable,
                IsAutoDeleted = option.QueueAutoDelete,
                IsExclusive   = option.QueueExclusive,
            };

            Start(hostOption, exchangeOption);
        }
示例#3
0
        /// <summary>
        /// Start publisher
        /// </summary>
        /// <param name="hostOption"></param>
        /// <param name="exchangeOption"></param>
        public void Start(HostOption hostOption, ExchangeOption exchangeOption, QueueOption queueOption)
        {
            mConnectionFactory = new ConnectionFactory()
            {
                ClientProvidedName = hostOption.ClientName,
                HostName           = hostOption.Host,
                Port        = hostOption.Port,
                VirtualHost = hostOption.VirtualHost,
                UserName    = hostOption.UserName,
                Password    = hostOption.Password,
                RequestedConnectionTimeout = TimeSpan.FromSeconds(hostOption.ConnectionTimeout),
                RequestedHeartbeat         = TimeSpan.FromSeconds(hostOption.HeartBeat)
            };

            mExchangeName = exchangeOption.ExchangeName;
            mExchangeType = exchangeOption.ExchangeType;
            mRoutingKey   = exchangeOption.RoutingKey;

            mConnection = mConnectionFactory.CreateConnection();

            mChannel = mConnection.CreateModel();
            if (queueOption != null && !string.IsNullOrWhiteSpace(queueOption.QueueName))
            {
                mQueueName       = queueOption.QueueName;
                mQueueDurable    = queueOption.IsDurable;
                mQueueAutoDelete = queueOption.IsAutoDeleted;
                mQueueExclusive  = queueOption.IsExclusive;

                mChannel.QueueDeclare(mQueueName, mQueueDurable, mQueueExclusive, mQueueAutoDelete);
            }

            mChannel.ExchangeDeclare(mExchangeName, mExchangeType);
        }
示例#4
0
        public QueueReceiver(QueueOption queueOption, string queueName, ILogger <QueueReceiver <T> > logger)
        {
            queueOption.VerifyNotNull(nameof(queueOption));
            queueName.VerifyNotEmpty(nameof(queueName));

            _messageReceiver = new MessageReceiver(queueOption.ToConnectionString(), queueName, ReceiveMode.PeekLock);
            _logger          = logger;
        }
示例#5
0
        public static void Verify(this QueueOption subject)
        {
            subject.VerifyNotNull(nameof(subject));

            subject.Namespace.VerifyNotEmpty(nameof(subject.Namespace));
            subject.QueueName.VerifyNotEmpty(nameof(subject.QueueName));
            subject.KeyName.VerifyNotEmpty(nameof(subject.KeyName));
            subject.AccessKey.VerifyNotEmpty(nameof(subject.AccessKey));
        }
示例#6
0
        public QueueAdmin(QueueOption queueOption, ILogger <QueueAdmin> logging)
        {
            queueOption.VerifyNotNull(nameof(queueOption));
            logging.VerifyNotNull(nameof(logging));

            ConnectionString  = queueOption.ToConnectionString();
            _managementClient = new ManagementClient(ConnectionString);
            _logging          = logging;
        }
示例#7
0
 public static string ToConnectionString(this QueueOption subject)
 {
     return(new ServiceBusConnectionStringBuilder
     {
         Endpoint = $"{subject.Namespace}.servicebus.windows.net",
         SasKeyName = subject.KeyName,
         SasKey = subject.AccessKey,
         TransportType = TransportType.Amqp,
     }.ToString());
 }
示例#8
0
        /// <summary>
        /// Creates a new FIFO queue
        /// </summary>
        /// <param name="limit">The maximum number of items allocated in the queue</param>
        /// <param name="collection">Queue is filled with items from the given collection.  All the items from the given collection will
        /// be initially added to the queue, even if there are more then the specified limit.  However, the next time an item is enqueued,
        /// the excess items will be removed until the queue is back within it's size limit.</param>
        /// <param name="queueOption">The options associated with the queue <see cref="QueueOption"/></param>
        public QueueFifoConcurrent(int limit, System.Collections.Generic.IEnumerable <TItem>?collection, QueueOption queueOption = QueueOption.None)
        {
            if (limit <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(limit), limit, $"Must be >= 0");
            }

            _queue    = collection == null ? new ConcurrentQueue <TItem>() : new ConcurrentQueue <TItem>(collection);
            LimitSize = limit;
            Option    = queueOption;
        }
示例#9
0
        public QueueClient(QueueOption queueOption, IQueueAwaiterService awaiterService, ILogger <QueueClient> logger)
        {
            queueOption.VerifyNotNull(nameof(queueOption));
            awaiterService.VerifyNotNull(nameof(awaiterService));
            logger.VerifyNotNull(nameof(logger));

            _awaiterService = awaiterService;
            _logger         = logger;

            _messageSender = new MessageSender(queueOption.ToConnectionString(), queueOption.Queue);
        }
示例#10
0
        public QueueClient(Func <T, Guid?> getId, QueueOption queueOption, IAwaiterCollection <T> awaiterService, ILogger <QueueClient <T> > logger)
        {
            getId.VerifyNotNull(nameof(getId));
            queueOption.VerifyNotNull(nameof(queueOption));
            awaiterService.VerifyNotNull(nameof(awaiterService));
            logger.VerifyNotNull(nameof(logger));

            _getId          = getId;
            _awaiterService = awaiterService;
            _logger         = logger;

            _messageSender = new MessageSender(queueOption.ToConnectionString(), queueOption.QueueName);
        }
示例#11
0
        /// <summary>
        /// Start consume
        /// </summary>
        /// <param name="hostOption"></param>
        /// <param name="exchangeOption"></param>
        /// <param name="queueOption"></param>
        public void Start(HostOption hostOption, ExchangeOption exchangeOption, QueueOption queueOption)
        {
            BindQueue(hostOption, exchangeOption, queueOption);

            //consuming by event
            mEventConsumer = new EventingBasicConsumer(mChannel);

            //registe events
            mEventConsumer.Received   += Consumer_Received;
            mEventConsumer.Registered += Consumer_Registered;
            mEventConsumer.Shutdown   += Consumer_Shutdown;

            mLastConsumerTag = mChannel.BasicConsume(mQueueName, mIsAutoAck, mLastConsumerTag, mEventConsumer);
        }
示例#12
0
        /// <summary>
        /// BindQueue
        /// </summary>
        /// <param name="hostOption"></param>
        /// <param name="exchangeOption"></param>
        /// <param name="queueOption"></param>
        protected void BindQueue(HostOption hostOption, ExchangeOption exchangeOption, QueueOption queueOption)
        {
            mHostOption     = hostOption;
            mExchangeOption = exchangeOption;
            mQueueOption    = queueOption;

            mQueueName = queueOption.QueueName;
            mIsAutoAck = queueOption.AutoAck;

            mLastConsumerTag = queueOption.ConsumerTag;
            if (string.IsNullOrWhiteSpace(mLastConsumerTag))
            {
                mLastConsumerTag = string.Empty;
            }

            try
            {
                var factory = new ConnectionFactory()
                {
                    ClientProvidedName = hostOption.ClientName,
                    HostName           = hostOption.Host,
                    Port        = hostOption.Port,
                    VirtualHost = hostOption.VirtualHost,
                    UserName    = hostOption.UserName,
                    Password    = hostOption.Password,

                    RequestedConnectionTimeout = TimeSpan.FromSeconds(hostOption.ConnectionTimeout),
                    RequestedHeartbeat         = TimeSpan.FromSeconds(hostOption.HeartBeat)
                };

                mConnection = factory.CreateConnection();

                mChannel = mConnection.CreateModel();

                mChannel.ExchangeDeclare(exchangeOption.ExchangeName, exchangeOption.ExchangeType);
                mChannel.QueueDeclare(queueOption.QueueName, queueOption.IsDurable, queueOption.IsExclusive, queueOption.IsAutoDeleted);
                mChannel.QueueBind(queueOption.QueueName, exchangeOption.ExchangeName, exchangeOption.RoutingKey);
                mChannel.BasicQos(0, queueOption.Qos, false);
            }
            catch (BrokerUnreachableException bex)
            {
                ConnectFail?.Invoke(this, new ConnectionFailEventArgs {
                    Message = bex.Message
                });
            }
            catch (ConnectFailureException cex)
            {
                ConnectFail?.Invoke(this, new ConnectionFailEventArgs {
                    Message = cex.Message
                });
            }
            catch (SocketException sex)
            {
                ConnectFail?.Invoke(this, new ConnectionFailEventArgs {
                    Message = sex.Message
                });
            }
            catch (Exception ex)
            {
                UnknowError?.Invoke(this, new UnknownExceptionEventArgs {
                    Message = ex.Message
                });
            }
        }
示例#13
0
 public override void Visit(QueueOption node) { this.action(node); }
 public override void ExplicitVisit(QueueOption fragment)
 {
     _fragments.Add(fragment);
 }
示例#15
0
        static void Main(string[] args)
        {
            IConsumer consumer = new Consumer(new SimpleJsonMessageDecoder());

            IConsumer <TestModel> consumerT = new Consumer <TestModel>(new SimpleJsonMessageDecoder());


            HostOption hostOption = new HostOption
            {
                ClientName  = "TestCreamCustardBun",
                Host        = "192.168.1.10",
                Port        = 5672,
                VirtualHost = "/dev",
                UserName    = "******",
                Password    = "******",
            };

            ExchangeOption exchangeOption = new ExchangeOption
            {
                ExchangeName  = "temp.exchange",
                ExchangeType  = "direct",
                IsDurable     = false,
                IsAutoDeleted = false,
                RoutingKey    = "temp.routingkey",
            };

            QueueOption queueOption = new QueueOption
            {
                IsDurable     = false,
                IsAutoDeleted = false,
                IsExclusive   = false,
                QueueName     = "temp.queue",
                ConsumerTag   = "",
            };

            MessageQueueOption option = new MessageQueueOption
            {
                ClientName         = "TestCreamCustardBun",
                Host               = "192.168.1.10",
                Port               = 5672,
                VirtualHost        = "/dev",
                UserName           = "******",
                Password           = "******",
                ExchangeName       = "temp.exchange",
                ExchangeType       = "direct",
                ExchangeDurable    = false,
                ExchangeAutoDelete = false,
                RoutingKey         = "temp.routingkey",
                QueueDurable       = false,
                QueueAutoDelete    = false,
                QueueExclusive     = false,
                QueueName          = "temp.queue",
                CustomerTag        = "",
                QueueAutoAck       = true
            };

            consumerT.MessageArrived += Consumer_MessageArrivedT;
            consumerT.Start(option);


            consumer.MessageArrived += Consumer_MessageArrived;
            consumer.Start(option);

            Console.ReadLine();
        }
示例#16
0
 /// <summary>
 /// Creates a new FIFO queue
 /// </summary>
 /// <param name="limit">The maximum number of items allocated in the queue</param>
 /// <param name="queueOption">The options associated with the queue <see cref="QueueOption"/></param>
 public QueueFifoConcurrent(int limit, QueueOption queueOption = QueueOption.None) : this(limit, null, queueOption)
 {
 }