static void Main(string[] args)
{
//Create host and register custom transport listener
var uri = new Uri(address);
var host = new ContainerHost(new List<Uri>() { uri }, null, uri.UserInfo);
host.CustomTransports.Add("pipe", NamedPipeTransport.Listener);
host.RegisterMessageProcessor(nodeName, new MessageProcessor());
host.Open();
Console.WriteLine("Listener: running");
//Create factory with custom transport factory
var factory = new ConnectionFactory(new TransportProvider[] { NamedPipeTransport.Factory });
var connection = factory.CreateAsync(new Address(address)).GetAwaiter().GetResult();
var session = new Session(connection);
var sender = new SenderLink(session, "message-client", nodeName);
Console.WriteLine("Client: sending a message");
sender.Send(new Message("Hello Pipe!"));
sender.Close();
session.Close();
connection.Close();
Console.WriteLine("Client: closed");
host.Close();
Console.WriteLine("Listener: closed");
}
async Task RunSampleAsync()
{
ConnectionFactory factory = new ConnectionFactory();
factory.SASL.Profile = SaslProfile.External;
Trace.WriteLine(TraceLevel.Information, "Establishing a connection...");
Address address = new Address(this.Namespace, 5671, null, null, "/", "amqps");
var connection = await factory.CreateAsync(address);
// before any operation can be performed, a token must be put to the $cbs node
Trace.WriteLine(TraceLevel.Information, "Putting a token to the $cbs node...");
await PutTokenAsync(connection);
Trace.WriteLine(TraceLevel.Information, "Sending a message...");
var session = new Session(connection);
var sender = new SenderLink(session, "ServiceBus.Cbs:sender-link", this.Entity);
await sender.SendAsync(new Message("test"));
await sender.CloseAsync();
Trace.WriteLine(TraceLevel.Information, "Receiving the message back...");
var receiver = new ReceiverLink(session, "ServiceBus.Cbs:receiver-link", this.Entity);
var message = await receiver.ReceiveAsync();
receiver.Accept(message);
await receiver.CloseAsync();
Trace.WriteLine(TraceLevel.Information, "Closing the connection...");
await session.CloseAsync();
await connection.CloseAsync();
}
static NmsConnectionInfo()
{
AmqpSettings defaultAmqpSettings = new Amqp.ConnectionFactory().AMQP;
DEFAULT_CHANNEL_MAX = defaultAmqpSettings.MaxSessionsPerConnection;
DEFAULT_MAX_FRAME_SIZE = defaultAmqpSettings.MaxFrameSize;
DEFAULT_IDLE_TIMEOUT = defaultAmqpSettings.IdleTimeout;
}
public async Task ConnectAsync(Address address, ConnectionFactory factory)
{
StreamSocket ss = new StreamSocket();
await ss.ConnectAsync(
new HostName(address.Host),
address.Port.ToString(),
address.UseSsl ? SocketProtectionLevel.Tls12 : SocketProtectionLevel.PlainSocket);
this.socket = ss;
}
static ConnectionInfo()
{
Amqp.ConnectionFactory defaultCF = new Amqp.ConnectionFactory();
AmqpSettings defaultAMQPSettings = defaultCF.AMQP;
DEFAULT_CHANNEL_MAX = defaultAMQPSettings.MaxSessionsPerConnection;
DEFAULT_MAX_FRAME_SIZE = defaultAMQPSettings.MaxFrameSize;
DEFAULT_IDLE_TIMEOUT = defaultAMQPSettings.IdleTimeout;
DEFAULT_REQUEST_TIMEOUT = Convert.ToInt64(NMSConstants.defaultRequestTimeout.TotalMilliseconds);
}
public void Connect(Connection connection, Address address, bool noVerification)
{
this.connection = connection;
var factory = new ConnectionFactory();
if (noVerification)
{
factory.SSL.RemoteCertificateValidationCallback = noneCertValidator;
}
this.ConnectAsync(address, factory).GetAwaiter().GetResult();
}
public ConnectionFactory(Uri brokerUri, string clientId, StringDictionary props)
{
impl = new Amqp.ConnectionFactory();
this.clientId = clientId;
if (props != null)
{
this.InitApplicationProperties(props);
}
BrokerUri = brokerUri;
impl.AMQP.HostName = BrokerUri.Host;
//
// Set up tracing in AMQP. We capture all AMQP traces in the TraceListener below
// and map to NMS 'Tracer' logs as follows:
// AMQP Tracer
// Verbose Debug
// Frame Debug
// Information Info
// Output Info (should not happen)
// Warning Warn
// Error Error
//
Amqp.Trace.TraceLevel = Amqp.TraceLevel.Verbose | Amqp.TraceLevel.Frame;
Amqp.Trace.TraceListener = (level, format, args) =>
{
switch (level)
{
case Amqp.TraceLevel.Verbose:
case Amqp.TraceLevel.Frame:
Tracer.DebugFormat(format, args);
break;
case Amqp.TraceLevel.Information:
case Amqp.TraceLevel.Output:
//
// Applications should not access AmqpLite directly so there
// should be no 'Output' level logs.
Tracer.InfoFormat(format, args);
break;
case Amqp.TraceLevel.Warning:
Tracer.WarnFormat(format, args);
break;
case Amqp.TraceLevel.Error:
Tracer.ErrorFormat(format, args);
break;
default:
Tracer.InfoFormat("Unknown AMQP LogLevel: {}", level);
Tracer.InfoFormat(format, args);
break;
}
};
}
public async Task ConnectAsync(Address address, ConnectionFactory factory)
{
Socket socket;
IPAddress[] ipAddresses;
IPAddress ipAddress;
if (IPAddress.TryParse(address.Host, out ipAddress))
{
socket = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
ipAddresses = new IPAddress[] { ipAddress };
}
else
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
ipAddresses = Dns.GetHostEntry(address.Host).AddressList;
}
if (factory.tcpSettings != null)
{
factory.tcpSettings.Configure(socket);
}
await Task.Factory.FromAsync(
(c, s) => ((Socket)s).BeginConnect(ipAddresses, address.Port, c, s),
(r) => ((Socket)r.AsyncState).EndConnect(r),
socket);
IAsyncTransport transport;
if (address.UseSsl)
{
SslStream sslStream;
var ssl = factory.SslInternal;
if (ssl == null)
{
sslStream = new SslStream(new NetworkStream(socket));
await sslStream.AuthenticateAsClientAsync(address.Host);
}
else
{
sslStream = new SslStream(new NetworkStream(socket), false, ssl.RemoteCertificateValidationCallback);
await sslStream.AuthenticateAsClientAsync(address.Host, ssl.ClientCertificates,
ssl.Protocols, ssl.CheckCertificateRevocation);
}
transport = new SslSocket(this, sslStream);
}
else
{
transport = new TcpSocket(this, socket);
}
this.socketTransport = transport;
this.writer = new Writer(this, this.socketTransport);
}
protected override void CopyBuilder(Amqp.ConnectionFactory copy)
{
base.CopyBuilder(copy);
copy.SSL.Protocols = connectionBuilder.SSL.Protocols;
copy.SSL.CheckCertificateRevocation = connectionBuilder.SSL.CheckCertificateRevocation;
if (connectionBuilder.SSL.ClientCertificates != null)
{
copy.SSL.ClientCertificates = new X509CertificateCollection(connectionBuilder.SSL.ClientCertificates);
}
}
public async Task <IConnection> CreateAsync(Endpoint endpoint, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
cancellationToken.Register(() => _tcs.TrySetCanceled());
var connectionFactory = new Amqp.ConnectionFactory();
var connection = await connectionFactory.CreateAsync(endpoint.Address, null, OnOpened).ConfigureAwait(false);
connection.AddClosedCallback(OnClosed);
await _tcs.Task.ConfigureAwait(false);
connection.Closed -= OnClosed;
return(new Connection(_loggerFactory, endpoint, connection, _messageIdPolicyFactory));
}
public async Task ConnectAsync(Address address, ConnectionFactory factory)
{
SocketProtectionLevel spl = !address.UseSsl ?
SocketProtectionLevel.PlainSocket :
#if NETFX_CORE
SocketProtectionLevel.Tls12;
#else
SocketProtectionLevel.Ssl;
#endif
StreamSocket ss = new StreamSocket();
await ss.ConnectAsync(new HostName(address.Host), address.Port.ToString(), spl);
this.socket = ss;
}
static async Task<int> SslConnectionTestAsync(string brokerUrl, string address, string certfile)
{
try
{
ConnectionFactory factory = new ConnectionFactory();
factory.TCP.NoDelay = true;
factory.TCP.SendBufferSize = 16 * 1024;
factory.TCP.SendTimeout = 30000;
factory.TCP.ReceiveBufferSize = 16 * 1024;
factory.TCP.ReceiveTimeout = 30000;
factory.SSL.RemoteCertificateValidationCallback = (a, b, c, d) => true;
factory.SSL.ClientCertificates.Add(X509Certificate.CreateFromCertFile(certfile));
factory.SSL.CheckCertificateRevocation = false;
factory.AMQP.MaxFrameSize = 64 * 1024;
factory.AMQP.HostName = "host.example.com";
factory.AMQP.ContainerId = "amq.topic";
Address sslAddress = new Address(brokerUrl);
Connection connection = await factory.CreateAsync(sslAddress);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender1", address);
ReceiverLink receiver = new ReceiverLink(session, "helloworld-receiver", address);
Message helloOut = new Message("Hello - using client cert");
await sender.SendAsync(helloOut);
Message helloIn = await receiver.ReceiveAsync();
receiver.Accept(helloIn);
await connection.CloseAsync();
Console.WriteLine("{0}", helloIn.Body.ToString());
Console.WriteLine("Press enter key to exit...");
Console.ReadLine();
return 0;
}
catch (Exception e)
{
Console.WriteLine("Exception {0}.", e);
return 1;
}
}
internal void Configure(ConnectionFactory cf)
{
Amqp.ConnectionFactory cfImpl = cf.Factory as Amqp.ConnectionFactory;
// get properties from connection factory
StringDictionary properties = cf.ConnectionProperties;
// apply connection properties to connection factory and connection info.
PropertyUtil.SetProperties(cfImpl.AMQP, properties, ConnectionFactory.ConnectionPropertyPrefix);
PropertyUtil.SetProperties(connInfo, properties, ConnectionFactory.ConnectionPropertyPrefix);
// create copy of transport context
this.transportContext = cf.Context.Copy();
// Store raw properties for future objects
this.properties = PropertyUtil.Clone(properties);
// Create Connection builder delegate.
this.implCreate = this.transportContext.CreateConnectionBuilder();
}
public async Task ConnectAsync(Address address, ConnectionFactory factory)
{
Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
if (factory.tcpSettings != null)
{
factory.tcpSettings.Configure(socket);
}
await Task.Factory.FromAsync(
(c, s) => ((Socket)s).BeginConnect(address.Host, address.Port, c, s),
(r) => ((Socket)r.AsyncState).EndConnect(r),
socket);
IAsyncTransport transport;
if (address.UseSsl)
{
SslStream sslStream;
var ssl = factory.SslInternal;
if (ssl == null)
{
sslStream = new SslStream(new NetworkStream(socket));
await sslStream.AuthenticateAsClientAsync(address.Host);
}
else
{
sslStream = new SslStream(new NetworkStream(socket), false, ssl.RemoteCertificateValidationCallback, ssl.LocalCertificateSelectionCallback);
await sslStream.AuthenticateAsClientAsync(address.Host, ssl.ClientCertificates,
ssl.Protocols, ssl.CheckCertificateRevocation);
}
transport = new SslSocket(this, sslStream);
}
else
{
transport = new TcpSocket(this, socket);
}
this.socketTransport = transport;
this.writer = new Writer(this, this.socketTransport);
}
public void ContainerHostX509PrincipalTest()
{
string name = MethodInfo.GetCurrentMethod().Name;
string address = "amqps://localhost:5676";
X509Certificate2 cert = GetCertificate(StoreLocation.LocalMachine, StoreName.My, "localhost");
ContainerHost sslHost = new ContainerHost(new Uri(address));
sslHost.Listeners[0].SSL.Certificate = cert;
sslHost.Listeners[0].SSL.ClientCertificateRequired = true;
sslHost.Listeners[0].SSL.RemoteCertificateValidationCallback = (a, b, c, d) => true;
sslHost.Listeners[0].SASL.EnableExternalMechanism = true;
ListenerLink link = null;
var linkProcessor = new TestLinkProcessor();
linkProcessor.OnLinkAttached += a => link = a;
sslHost.RegisterLinkProcessor(linkProcessor);
sslHost.Open();
try
{
var factory = new ConnectionFactory();
factory.SSL.RemoteCertificateValidationCallback = (a, b, c, d) => true;
factory.SSL.ClientCertificates.Add(cert);
factory.SASL.Profile = SaslProfile.External;
var connection = factory.CreateAsync(new Address(address)).Result;
var session = new Session(connection);
var sender = new SenderLink(session, name, name);
sender.Send(new Message("msg1"), SendTimeout);
connection.Close();
Assert.IsTrue(link != null, "link is null");
var listenerConnection = (ListenerConnection)link.Session.Connection;
Assert.IsTrue(listenerConnection.Principal != null, "principal is null");
Assert.IsTrue(listenerConnection.Principal.Identity.AuthenticationType == "X509", "wrong auth type");
X509Identity identity = (X509Identity)listenerConnection.Principal.Identity;
Assert.IsTrue(identity.Certificate != null, "certificate is null");
}
finally
{
sslHost.Close();
}
}
internal TransportContext()
{
connectionBuilder = new Amqp.ConnectionFactory();
connectionBuilder.SASL.Profile = Amqp.Sasl.SaslProfile.Anonymous;
}
public async Task WebSocketSslMutalAuthTest()
{
string testName = "WebSocketSslMutalAuthTest";
string listenAddress = "wss://localhost:18081/" + testName + "/";
Uri uri = new Uri(listenAddress);
X509Certificate2 cert = ContainerHostTests.GetCertificate(StoreLocation.LocalMachine, StoreName.My, "localhost");
string output;
int code = Exec("netsh.exe", string.Format("http show sslcert hostnameport={0}:{1}", uri.Host, uri.Port), out output);
if (code != 0)
{
string args = string.Format("http add sslcert hostnameport={0}:{1} certhash={2} certstorename=MY appid={{{3}}} clientcertnegotiation=enable",
uri.Host, uri.Port, cert.Thumbprint, Guid.NewGuid());
code = Exec("netsh.exe", args, out output);
Assert.AreEqual(0, code, "failed to add ssl cert: " + output);
}
X509Certificate serviceCert = null;
X509Certificate clientCert = null;
ListenerLink listenerLink = null;
var linkProcessor = new TestLinkProcessor() { OnLinkAttached = c => listenerLink = c };
var host = new ContainerHost(new List<Uri>() { uri }, null, uri.UserInfo);
host.Listeners[0].SASL.EnableExternalMechanism = true;
host.Listeners[0].SSL.ClientCertificateRequired = true;
host.Listeners[0].SSL.CheckCertificateRevocation = true;
host.Listeners[0].SSL.RemoteCertificateValidationCallback = (a, b, c, d) => { clientCert = b; return true; };
host.RegisterLinkProcessor(linkProcessor);
host.Open();
try
{
ServicePointManager.ServerCertificateValidationCallback = (a, b, c, d) => { serviceCert = b; return true; };
var wssFactory = new WebSocketTransportFactory();
wssFactory.Options = o =>
{
o.ClientCertificates.Add(ContainerHostTests.GetCertificate(StoreLocation.LocalMachine, StoreName.My, uri.Host));
};
ConnectionFactory connectionFactory = new ConnectionFactory(new TransportProvider[] { wssFactory });
connectionFactory.SASL.Profile = SaslProfile.External;
Connection connection = await connectionFactory.CreateAsync(new Address(listenAddress));
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, "q1");
await sender.SendAsync(new Message("test") { Properties = new Properties() { MessageId = testName } });
await connection.CloseAsync();
Assert.IsTrue(serviceCert != null, "service cert not received");
Assert.IsTrue(clientCert != null, "client cert not received");
Assert.IsTrue(listenerLink != null, "link not attached");
IPrincipal principal = ((ListenerConnection)listenerLink.Session.Connection).Principal;
Assert.IsTrue(principal != null, "connection pricipal is null");
Assert.IsTrue(principal.Identity is X509Identity, "identify should be established by client cert");
}
finally
{
host.Close();
}
}
public async Task WebSocketSendReceiveAsync()
{
if (Environment.GetEnvironmentVariable("CoreBroker") == "1")
{
// No Websocket listener on .Net Core
return;
}
string testName = "WebSocketSendReceiveAsync";
// assuming it matches the broker's setup and port is not taken
Address wsAddress = new Address(address);
int nMsgs = 50;
ConnectionFactory connectionFactory = new ConnectionFactory(
new TransportProvider[] { new WebSocketTransportFactory() });
Connection connection = await connectionFactory.CreateAsync(wsAddress);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, "q1");
for (int i = 0; i < nMsgs; ++i)
{
Message message = new Message();
message.Properties = new Properties() { MessageId = "msg" + i, GroupId = testName };
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["sn"] = i;
await sender.SendAsync(message);
}
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, "q1");
for (int i = 0; i < nMsgs; ++i)
{
Message message = await receiver.ReceiveAsync();
Trace.WriteLine(TraceLevel.Information, "receive: {0}", message.ApplicationProperties["sn"]);
receiver.Accept(message);
}
await sender.CloseAsync();
await receiver.CloseAsync();
await session.CloseAsync();
await connection.CloseAsync();
}
public async Task CustomTransportConfiguration()
{
string testName = "CustomTransportConfiguration";
ConnectionFactory factory = new ConnectionFactory();
factory.TCP.NoDelay = true;
factory.TCP.SendBufferSize = 16 * 1024;
factory.TCP.SendTimeout = 30000;
factory.SSL.RemoteCertificateValidationCallback = (a, b, c, d) => true;
factory.AMQP.MaxFrameSize = 64 * 1024;
factory.AMQP.HostName = "contoso.com";
factory.AMQP.ContainerId = "container:" + testName;
Address sslAddress = new Address("amqps://*****:*****@127.0.0.1:5671");
Connection connection = await factory.CreateAsync(sslAddress);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
Message message = new Message("custom transport config");
message.Properties = new Properties() { MessageId = testName };
await sender.SendAsync(message);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
Message message2 = await receiver.ReceiveAsync();
Assert.IsTrue(message2 != null, "no message received");
receiver.Accept(message2);
await connection.CloseAsync();
}
public void Connect(Connection connection, Address address, bool noVerification)
{
this.connection = connection;
var factory = new ConnectionFactory();
this.ConnectAsync(address, factory).ConfigureAwait(false).GetAwaiter().GetResult();
}
public void ContainerHostCustomTransportTest()
{
string name = "ContainerHostCustomTransportTest";
string address = "pipe://./" + name;
ContainerHost host = new ContainerHost(new Uri(address));
host.CustomTransports.Add("pipe", NamedPipeTransport.Listener);
host.RegisterMessageProcessor(name, new TestMessageProcessor());
host.Open();
try
{
var factory = new ConnectionFactory(new TransportProvider[] { NamedPipeTransport.Factory });
var connection = factory.CreateAsync(new Address(address)).GetAwaiter().GetResult();
var session = new Session(connection);
var sender = new SenderLink(session, name, name);
sender.Send(new Message("msg1"), SendTimeout);
connection.Close();
}
finally
{
host.Close();
}
}
protected Connection CreateConnection(Address address)
{
var factory = new ConnectionFactory();
if (address.Scheme.Equals("amqps", StringComparison.OrdinalIgnoreCase))
{
factory.SSL.RemoteCertificateValidationCallback = (a, b, c, d) => true;
}
return factory.CreateAsync(address).Result;
}
protected Connection CreateConnection(Address address)
{
var factory = new ConnectionFactory();
factory.BufferManager = this.bufferManager;
factory.AMQP.MaxFrameSize = this.perfArgs.MaxFrameSize;
if (address.Scheme.Equals("amqps", StringComparison.OrdinalIgnoreCase))
{
factory.SSL.RemoteCertificateValidationCallback = (a, b, c, d) => true;
}
return factory.CreateAsync(address).Result;
}
public async Task ConnectAsync(Address address, ConnectionFactory factory)
{
IPAddress[] ipAddresses;
IPAddress ip;
if (IPAddress.TryParse(address.Host, out ip))
{
ipAddresses = new IPAddress[] { ip };
}
else
{
ipAddresses = await TaskExtensions.GetHostAddressesAsync(address.Host);
}
// need to handle both IPv4 and IPv6
Socket socket = null;
Exception exception = null;
for (int i = 0; i < ipAddresses.Length; i++)
{
if (ipAddresses[i] == null ||
(ipAddresses[i].AddressFamily == AddressFamily.InterNetwork && !Socket.OSSupportsIPv4) ||
(ipAddresses[i].AddressFamily == AddressFamily.InterNetworkV6 && !Socket.OSSupportsIPv6))
{
continue;
}
socket = new Socket(ipAddresses[i].AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
await socket.ConnectAsync(ipAddresses[i], address.Port);
exception = null;
break;
}
catch (Exception e)
{
exception = e;
socket.Dispose();
socket = null;
}
}
if (socket == null)
{
throw exception ?? new SocketException((int)SocketError.AddressNotAvailable);
}
if (factory.tcpSettings != null)
{
factory.tcpSettings.Configure(socket);
}
IAsyncTransport transport;
if (address.UseSsl)
{
SslStream sslStream;
var ssl = factory.SslInternal;
if (ssl == null)
{
sslStream = new SslStream(new NetworkStream(socket));
await sslStream.AuthenticateAsClientAsync(address.Host);
}
else
{
sslStream = new SslStream(new NetworkStream(socket), false, ssl.RemoteCertificateValidationCallback, ssl.LocalCertificateSelectionCallback);
await sslStream.AuthenticateAsClientAsync(address.Host, ssl.ClientCertificates,
ssl.Protocols, ssl.CheckCertificateRevocation);
}
transport = new SslSocket(this, sslStream);
}
else
{
transport = new TcpSocket(this, socket);
}
this.socketTransport = transport;
this.writer = new Writer(this, this.socketTransport);
}
public async void Start(string address)
{
ConnectionFactory factory = new ConnectionFactory();
try
{
this.connection = await factory.CreateAsync(new Address(address));
this.session = new Session(connection);
this.sender = new SenderLink(session, "send-link", "control");
this.receiver = new ReceiverLink(session, "recv-link", "data");
this.receiver.Start(50, this.OnMessage);
}
catch
{
this.Message = "err:2";
}
}
public async void Start()
{
Address address = new Address("amqp://*****:*****@192.168.1.120:5672");
ConnectionFactory factory = new ConnectionFactory();
try
{
this.connection = await factory.CreateAsync(address);
this.session = new Session(connection);
this.sender = new SenderLink(session, "send-link", "control");
this.receiver = new ReceiverLink(session, "recv-link", "data");
this.receiver.Start(50, this.OnMessage);
}
catch
{
this.Message = "err:2";
}
}
static void Main(string[] args)
{
//Trace.TraceLevel = TraceLevel.Frame;
//Trace.TraceListener = (f, a) => Console.WriteLine(DateTime.Now.ToString("[hh:ss.fff]") + " " + string.Format(f, a));
string address = "amqps://localhost:5671";
// start a host with custom SSL and SASL settings
Console.WriteLine("Starting server...");
Uri addressUri = new Uri(address);
ContainerHost host = new ContainerHost(addressUri);
var listener = host.Listeners[0];
listener.SSL.Certificate = GetCertificate("localhost");
listener.SSL.ClientCertificateRequired = true;
listener.SSL.RemoteCertificateValidationCallback = ValidateServerCertificate;
listener.SASL.EnableExternalMechanism = true;
host.Open();
Console.WriteLine("Container host is listening on {0}:{1}", addressUri.Host, addressUri.Port);
string messageProcessor = "message_processor";
host.RegisterMessageProcessor(messageProcessor, new MessageProcessor());
Console.WriteLine("Message processor is registered on {0}", messageProcessor);
Console.WriteLine("Starting client...");
ConnectionFactory factory = new ConnectionFactory();
factory.SSL.ClientCertificates.Add(GetCertificate("localhost"));
factory.SSL.RemoteCertificateValidationCallback = ValidateServerCertificate;
factory.SASL.Profile = SaslProfile.External;
Console.WriteLine("Sending message...");
Connection connection = factory.CreateAsync(new Address(address)).Result;
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "certificate-example-sender", "message_processor");
sender.Send(new Message("hello world"));
sender.Close();
session.Close();
connection.Close();
Console.WriteLine("client done");
host.Close();
Console.WriteLine("server stopped");
}
public void ContainerHostSaslAnonymousTest()
{
string name = MethodInfo.GetCurrentMethod().Name;
ListenerLink link = null;
var linkProcessor = new TestLinkProcessor();
linkProcessor.OnLinkAttached += a => link = a;
this.host.RegisterLinkProcessor(linkProcessor);
var factory = new ConnectionFactory();
factory.SASL.Profile = SaslProfile.Anonymous;
var connection = factory.CreateAsync(new Address(Address.Host, Address.Port, null, null, "/", Address.Scheme)).Result;
var session = new Session(connection);
var sender = new SenderLink(session, name, name);
sender.Send(new Message("msg1"), SendTimeout);
connection.Close();
Assert.IsTrue(link != null, "link is null");
var listenerConnection = (ListenerConnection)link.Session.Connection;
Assert.IsTrue(listenerConnection.Principal == null, "principal should be null");
}
