Пример #1
0
        /// <summary>
        /// Common initialization code.
        /// </summary>
        protected virtual void Initialize(Dictionary <string, string> configuration, ZeroMqSocketType socketType, bool isInbound, IQueueLogger loggerObject = null)
        {
            try
            {
                #region Logger Initialization
                logger = loggerObject;
                #endregion

                #region Parameters Collection
                zmqConfiguration = CommonItems.CollectZmqConfiguration(ref configuration, isInbound, ref logger);
                #endregion

                #region Creating Socket
                InitializeZeroMqSocket(socketType, isInbound);
                #endregion
            }
            catch (Exception ex) when(!(ex is QueueException))
            {
                throw MessageQueueCommonItems.PrepareAndLogQueueException(
                          errorCode: QueueErrorCode.FailedToInitializeMessageQueue,
                          message: ErrorMessages.FailedToInitializeMessageQueue,
                          innerException: ex,
                          queueContext: CommonItems.ZeroMqName,
                          address: zmqConfiguration.Address,
                          logger: logger);
            }
        }
Пример #2
0
        /// <summary>
        /// Helper method to create and initialize different types of ZeroMq sockets.
        /// </summary>
        private void InitializeZeroMqSocket(ZeroMqSocketType socketType, bool isInbound)
        {
            try
            {
                #region Initialization
                switch (socketType)
                {
                case ZeroMqSocketType.Pair:
                {
                    socket = new PairSocket(zmqConfiguration.Address);
                    break;
                }

                case ZeroMqSocketType.Pull:
                {
                    socket = new PullSocket(zmqConfiguration.Address);
                    break;
                }

                case ZeroMqSocketType.Push:
                {
                    socket = new PushSocket(zmqConfiguration.Address);
                    break;
                }

                case ZeroMqSocketType.Dealer:
                {
                    socket = new DealerSocket(zmqConfiguration.Address);
                    break;
                }

                case ZeroMqSocketType.Router:
                {
                    socket = new RouterSocket(zmqConfiguration.Address);
                    break;
                }

                default:
                    throw MessageQueueCommonItems.PrepareAndLogQueueException(
                              errorCode: QueueErrorCode.InvalidZeroMqSocketType,
                              message: ErrorMessages.InvalidZeroMqSocketType,
                              innerException: null,
                              queueContext: CommonItems.ZeroMqName,
                              address: zmqConfiguration.Address,
                              logger: logger);
                }

                // Setting options.
                socket.Options.Linger = Defaults.ZeroMqLinger;

                if (isInbound)
                {
                    socket.Options.ReceiveHighWatermark = Defaults.ZeroMqReceiveHighWatermark;
                }
                else
                {
                    socket.Options.SendHighWatermark = Defaults.ZeroMqSendHighWatermark;
                }
                #endregion
            }
            catch (Exception ex) when(!(ex is QueueException))
            {
                throw MessageQueueCommonItems.PrepareAndLogQueueException(
                          errorCode: QueueErrorCode.FailedToCreateZeroMqSocket,
                          message: ErrorMessages.FailedToCreateZeroMqSocket,
                          innerException: ex,
                          queueContext: CommonItems.ZeroMqName,
                          address: zmqConfiguration?.Address,
                          logger: logger);
            }
        }