private AmqpTransportListener CreateTransportListener()
        {
            TransportListener    transportListener;
            TcpTransportSettings tcpTransportSetting = new TcpTransportSettings();
            int port = this.ListenUri.Port;

            if (port <= 0)
            {
                port = 5672;
            }
            tcpTransportSetting.Host = this.ListenUri.Host;
            tcpTransportSetting.Port = port;
            if (!this.ListenUri.Scheme.Equals("amqps", StringComparison.OrdinalIgnoreCase))
            {
                transportListener = tcpTransportSetting.CreateListener();
            }
            else
            {
                TlsTransportProvider transportProvider = this.amqpSettings.GetTransportProvider <TlsTransportProvider>();
                if (transportProvider == null)
                {
                    throw Fx.Exception.Argument("TlsSecurityProvider", "Tls provider must be set.");
                }
                TlsTransportSettings tlsTransportSetting = new TlsTransportSettings(tcpTransportSetting, false)
                {
                    Certificate = transportProvider.Settings.Certificate
                };
                transportListener = tlsTransportSetting.CreateListener();
            }
            return(new AmqpTransportListener(new TransportListener[] { transportListener }, this.amqpSettings));
        }
        static AmqpTransportListener CreateListener(IEnumerable <string> addresses, AmqpSettings settings)
        {
            List <TransportListener> listeners = new List <TransportListener>();

            foreach (string address in addresses)
            {
                Uri  uri     = new Uri(address);
                bool isAmqps = string.Equals(AmqpConstants.SchemeAmqps, uri.Scheme, StringComparison.OrdinalIgnoreCase);
                TcpTransportSettings tcpSettings = new TcpTransportSettings()
                {
                    Host = uri.Host,
                    Port = uri.Port < 0 ? (isAmqps ? AmqpConstants.DefaultSecurePort : AmqpConstants.DefaultPort) : uri.Port
                };

                TransportListener tpListener;
                if (isAmqps)
                {
                    var tlsProvider = settings.GetTransportProvider <TlsTransportProvider>();
                    if (tlsProvider == null)
                    {
                        throw new InvalidOperationException($"TlsTransportProvider must be in AmqpSettings.TransportProviders for '{address}'.");
                    }

                    if (tlsProvider.Settings.Certificate == null)
                    {
                        throw new InvalidOperationException($"A server certificate is required in TlsTransportProvider for '{address}'.");
                    }

                    TlsTransportSettings tlsSettings = new TlsTransportSettings(tcpSettings, false);
                    tlsSettings.Certificate = tlsProvider.Settings.Certificate;
                    tlsSettings.CertificateValidationCallback = tlsProvider.Settings.CertificateValidationCallback;
                    tlsSettings.CheckCertificateRevocation    = tlsProvider.Settings.CheckCertificateRevocation;

                    tpListener = tlsSettings.CreateListener();
                }
                else
                {
                    tpListener = tcpSettings.CreateListener();
                }

                listeners.Add(tpListener);
            }

            if (settings.GetTransportProvider <AmqpTransportProvider>() == null)
            {
                var amqpProvider = new AmqpTransportProvider(AmqpVersion.V100);
                settings.TransportProviders.Add(amqpProvider);
            }

            return(new AmqpTransportListener(listeners, settings));
        }
        protected ConnectionListener(
            Uri addressUri,
            AmqpSettings amqpSettings,
            AmqpConnectionSettings connectionSettings)
        {
            amqpSettings.ValidateListenerSettings();
            this.listenAddress      = addressUri;
            this.amqpSettings       = amqpSettings;
            this.connectionSettings = connectionSettings;
            this.onAcceptTransport  = this.OnAcceptTransport;

            TcpTransportSettings tcpSettings = new TcpTransportSettings();

            tcpSettings.SetEndPoint(addressUri.Host, addressUri.Port, true);
            TransportListener tpListener = null;

            if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqps, StringComparison.OrdinalIgnoreCase))
            {
                TlsTransportProvider tlsProvider = this.amqpSettings.GetTransportProvider <TlsTransportProvider>();
                if (tlsProvider == null)
                {
                    throw Fx.Exception.ArgumentNull("TlsSecurityProvider");
                }

                Fx.Assert(tlsProvider.Settings.Certificate != null, "Must have a valid certificate.");
                TlsTransportSettings tlsSettings = new TlsTransportSettings(tcpSettings, false);
                tlsSettings.Certificate = tlsProvider.Settings.Certificate;
                tpListener = tlsSettings.CreateListener();
            }
            else
            {
                tpListener = tcpSettings.CreateListener();
            }

            this.transportListener        = new AmqpTransportListener(new TransportListener[] { tpListener }, this.amqpSettings);
            this.onConnectionOpenComplete = new AsyncCallback(this.OnConnectionOpenComplete);
        }
Beispiel #4
0
        public TestAmqpBroker(IList <string> endpoints, string userInfo, string sslValue, string[] queues)
        {
            this.containerId  = "TestAmqpBroker-P" + Process.GetCurrentProcess().Id;
            this.maxFrameSize = 64 * 1024;
            this.txnManager   = new TxnManager();
            this.connections  = new Dictionary <SequenceNumber, AmqpConnection>();
            this.queues       = new Dictionary <string, TestQueue>();
            if (queues != null)
            {
                foreach (string q in queues)
                {
                    this.queues.Add(q, new TestQueue(this));
                }
            }
            else
            {
                this.implicitQueue = true;
            }

            // create and initialize AmqpSettings
            AmqpSettings     settings    = new AmqpSettings();
            X509Certificate2 certificate = sslValue == null ? null : GetCertificate(sslValue);

            settings.RuntimeProvider = this;

            SaslHandler saslHandler;

            if (userInfo != null)
            {
                string[] creds     = userInfo.Split(':');
                string   usernanme = Uri.UnescapeDataString(creds[0]);
                string   password  = creds.Length == 1 ? string.Empty : Uri.UnescapeDataString(creds[1]);
                saslHandler = new SaslPlainHandler(new TestPlainAuthenticator(userInfo, password));
            }
            else
            {
                saslHandler = new SaslAnonymousHandler();
            }

            SaslTransportProvider saslProvider = new SaslTransportProvider();

            saslProvider.AddHandler(saslHandler);
            saslProvider.Versions.Add(new AmqpVersion(1, 0, 0));
            settings.TransportProviders.Add(saslProvider);

            AmqpTransportProvider amqpProvider = new AmqpTransportProvider();

            amqpProvider.Versions.Add(new AmqpVersion(1, 0, 0));
            settings.TransportProviders.Add(amqpProvider);

            // create and initialize transport listeners
            TransportListener[] listeners = new TransportListener[endpoints.Count];
            for (int i = 0; i < endpoints.Count; i++)
            {
                Uri addressUri = new Uri(endpoints[i]);

                if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqps, StringComparison.OrdinalIgnoreCase))
                {
                    if (certificate == null)
                    {
                        throw new InvalidOperationException("/cert option was not set when amqps address is specified.");
                    }

                    TcpTransportSettings tcpSettings = new TcpTransportSettings()
                    {
                        Host = addressUri.Host, Port = addressUri.Port
                    };
                    TlsTransportSettings tlsSettings = new TlsTransportSettings(tcpSettings)
                    {
                        Certificate = certificate, IsInitiator = false
                    };
                    listeners[i] = tlsSettings.CreateListener();
                }
                else if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqp, StringComparison.OrdinalIgnoreCase))
                {
                    TcpTransportSettings tcpSettings = new TcpTransportSettings()
                    {
                        Host = addressUri.Host, Port = addressUri.Port
                    };
                    listeners[i] = tcpSettings.CreateListener();
                }
#if !NETSTANDARD
                else if (addressUri.Scheme.Equals("ws", StringComparison.OrdinalIgnoreCase))
                {
                    WebSocketTransportSettings wsSettings = new WebSocketTransportSettings()
                    {
                        Uri = addressUri
                    };
                    listeners[i] = wsSettings.CreateListener();
                }
#endif
                else
                {
                    throw new NotSupportedException(addressUri.Scheme);
                }
            }

            this.transportListener = new AmqpTransportListener(listeners, settings);
            this.settings          = settings;
        }
Beispiel #5
0
        public void Start()
        {
            // create and initialize AmqpSettings
            AmqpSettings     settings    = new AmqpSettings();
            X509Certificate2 certificate = this.sslValue == null ? null : GetCertificate(this.sslValue);

            settings.RuntimeProvider = this;

            SaslHandler saslHandler;

            if (this.userInfo != null)
            {
                string[] creds     = this.userInfo.Split(':');
                string   usernanme = Uri.UnescapeDataString(creds[0]);
                string   password  = creds.Length == 1 ? string.Empty : Uri.UnescapeDataString(creds[1]);
                saslHandler = new SaslPlainHandler(new TestPlainAuthenticator(this.userInfo, password));
            }
            else
            {
                saslHandler = new SaslAnonymousHandler();
            }

            SaslTransportProvider saslProvider = new SaslTransportProvider(AmqpVersion.V100);

            saslProvider.AddHandler(saslHandler);
            settings.TransportProviders.Add(saslProvider);

            AmqpTransportProvider amqpProvider = new AmqpTransportProvider(AmqpVersion.V100);

            settings.TransportProviders.Add(amqpProvider);

            // create and initialize transport listeners
            TransportListener[] listeners = new TransportListener[this.endpoints.Count];
            for (int i = 0; i < this.endpoints.Count; i++)
            {
                Uri addressUri = new Uri(this.endpoints[i]);

                if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqps, StringComparison.OrdinalIgnoreCase))
                {
                    if (certificate == null)
                    {
                        throw new InvalidOperationException("/cert option was not set when amqps address is specified.");
                    }

                    TcpTransportSettings tcpSettings = new TcpTransportSettings()
                    {
                        Host = addressUri.Host, Port = addressUri.Port
                    };
                    TlsTransportSettings tlsSettings = new TlsTransportSettings(tcpSettings)
                    {
                        Certificate = certificate, IsInitiator = false
                    };
                    listeners[i] = tlsSettings.CreateListener();
                }
                else if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqp, StringComparison.OrdinalIgnoreCase))
                {
                    TcpTransportSettings tcpSettings = new TcpTransportSettings()
                    {
                        Host = addressUri.Host, Port = addressUri.Port
                    };
                    listeners[i] = tcpSettings.CreateListener();
                }
                else if (addressUri.Scheme.Equals("ws", StringComparison.OrdinalIgnoreCase))
                {
                    WebSocketTransportSettings wsSettings = new WebSocketTransportSettings()
                    {
                        Uri = addressUri
                    };
                    listeners[i] = wsSettings.CreateListener();
                }
                else
                {
                    throw new NotSupportedException(addressUri.Scheme);
                }
            }

            this.settings          = settings;
            this.transportListener = new AmqpTransportListener(listeners, settings);
            this.transportListener.Listen(this.OnAcceptTransport);
        }