public void ContainerHostPlainPrincipalTest()
{
string name = MethodInfo.GetCurrentMethod().Name;
ListenerLink link = null;
var linkProcessor = new TestLinkProcessor();
linkProcessor.OnLinkAttached += a => link = a;
this.host.RegisterLinkProcessor(linkProcessor);
var connection = new Connection(Address);
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 == "PLAIN", "wrong auth type");
}
public async Task IsAuthorized_ReturnsTrue_WhenConnectionAuthorized()
{
ListenerLink link = null;
var authorized = false;
ILinkProcessor fakeLinkProcessor = Substitute.For <ILinkProcessor>();
fakeLinkProcessor
.When(instance => instance.Process(Arg.Any <AttachContext>()))
.Do(c =>
{
AttachContext attachContext = c.ArgAt <AttachContext>(0);
link = attachContext.Link;
attachContext.Complete(new Error(ErrorCode.IllegalState)
{
Description = "Test"
});
});
ContainerHost host = TestAmqpHost.Open();
try
{
host.RegisterLinkProcessor(fakeLinkProcessor);
Connection connection = await host.ConnectAndAttachAsync();
var securityContext = new SecurityContext();
securityContext.Authorize(link.Session.Connection);
authorized = securityContext.IsAuthorized(link.Session.Connection);
await connection.CloseAsync();
}
finally
{
host.Close();
}
authorized.ShouldBeTrue();
}
static void OnMessage(ListenerLink link, Message message, DeliveryState deliveryState, object state)
{
var thisPtr = (Publisher)state;
string errorCondition = null;
if (message.ApplicationProperties != null &&
(errorCondition = (string)message.ApplicationProperties["errorcondition"]) != null)
{
link.DisposeMessage(
message,
new Rejected()
{
Error = new Error()
{
Condition = errorCondition, Description = "message was rejected"
}
},
true);
}
else
{
var txnState = deliveryState as TransactionalState;
if (txnState != null)
{
Transaction txn = thisPtr.queue.broker.txnManager.GetTransaction(txnState.TxnId);
txn.AddOperation(message, onDischarge, thisPtr);
txnState.Outcome = new Accepted();
}
else
{
thisPtr.queue.Enqueue((BrokerMessage)message);
deliveryState = new Accepted();
}
thisPtr.link.DisposeMessage(message, deliveryState, true);
}
}
public void ContainerHostSaslAnonymousTest()
{
string name = "ContainerHostSaslAnonymousTest";
ListenerLink link = null;
var linkProcessor = new TestLinkProcessor();
linkProcessor.OnLinkAttached += a => link = a;
this.host.RegisterLinkProcessor(this.linkProcessor = 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");
}
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 ClientToServerLinkEndpoint(ListenerLink link)
: base(link)
{
}
void RemoveCoordinator(ListenerLink link)
{
lock (this.coordinators)
{
this.coordinators.Remove(link);
}
}
static void OnMessage(ListenerLink link, Message message, DeliveryState deliveryState, object state)
{
var thisPtr = (Publisher)state;
string errorCondition = null;
if (message.ApplicationProperties != null &&
(errorCondition = (string)message.ApplicationProperties["errorcondition"]) != null)
{
link.DisposeMessage(
message,
new Rejected() { Error = new Error() { Condition = errorCondition, Description = "message was rejected" } },
true);
}
else
{
var txnState = deliveryState as TransactionalState;
if (txnState != null)
{
Transaction txn = thisPtr.queue.broker.txnManager.GetTransaction(txnState.TxnId);
txn.AddOperation(message, onDischarge, thisPtr);
txnState.Outcome = new Accepted();
}
else
{
thisPtr.queue.Enqueue((BrokerMessage)message);
deliveryState = new Accepted();
}
thisPtr.link.DisposeMessage(message, deliveryState, true);
}
}
public Consumer(TestQueue queue, ListenerLink link, int id)
{
this.queue = queue;
this.link = link;
this.id = id;
link.Closed += this.OnLinkClosed;
link.InitializeSender(onCredit, onDispose, this);
}
public Publisher(TestQueue queue, ListenerLink link, int id)
{
this.queue = queue;
this.link = link;
this.id = id;
link.Closed += this.OnLinkClosed;
link.InitializeReceiver(200, onMessage, this);
}
public void CreatePublisher(ListenerLink link)
{
int id = Interlocked.Increment(ref this.currentId);
Publisher publisher = new Publisher(this, link, id);
lock (this.publishers)
{
this.publishers.Add(id, publisher);
}
}
public void CreateConsumer(ListenerLink link)
{
int id = Interlocked.Increment(ref this.currentId);
Consumer consumer = new Consumer(this, link, id);
lock (this.consumers)
{
this.consumers.Add(id, consumer);
}
}
public ServerLinkEndpoint(ListenerLink link)
{
this.Link = link;
}
public async Task Should_not_recreate_consumer_when_resource_deleted()
{
var host1 = CreateOpenedContainerHost();
var host2 = CreateContainerHost();
var host3 = CreateContainerHost();
ListenerLink listenerLink1 = null;
host1.CreateTestLinkProcessor().SetHandler(context =>
{
listenerLink1 = context.Link;
return(false);
});
await using var connection = await CreateConnection(new[] { host1.Endpoint, host2.Endpoint, host3.Endpoint });
var consumer = await connection.CreateConsumerAsync("a1", RoutingType.Anycast);
var receiveTask = consumer.ReceiveAsync(CancellationToken);
try
{
await listenerLink1.CloseAsync(Timeout, new Error(ErrorCode.ResourceDeleted) { Description = "Queue was deleted: a1" });
}
catch (Exception)
{
// ignored
}
await Assert.ThrowsAsync <ConsumerClosedException>(async() => await receiveTask);
await DisposeHostAndWaitUntilConnectionNotified(host1, connection);
var waitUntilConnectionRecoveredTask = WaitUntilConnectionRecovered(connection);
host2.CreateTestLinkProcessor().SetHandler(context =>
{
context.Complete(new Error(ErrorCode.NotFound)
{
Description = "Queue: 'a1' does not exist"
});
return(true);
});
host2.Open();
// wait until the connection recovered
await waitUntilConnectionRecoveredTask;
// make sure that the consumer remains closed
await Assert.ThrowsAsync <ConsumerClosedException>(async() => await consumer.ReceiveAsync(CancellationToken));
// perform again auto-recovery cycle, to make sure that
// no further attempts to recover the consumer will be made
await DisposeHostAndWaitUntilConnectionNotified(host2, connection);
waitUntilConnectionRecoveredTask = WaitUntilConnectionRecovered(connection);
ListenerLink listenerLink3 = null;
host3.CreateTestLinkProcessor().SetHandler(context =>
{
listenerLink3 = context.Link;
return(false);
});
host3.Open();
// wait until the connection recovered
await waitUntilConnectionRecoveredTask;
// make sure that no listener link was created on the final host
Assert.Null(listenerLink3);
}
public void AddCoordinator(ListenerLink link)
{
lock (this.coordinators)
{
this.coordinators.Add(link);
}
link.Closed += (o, e) => this.RemoveCoordinator((ListenerLink)o);
link.InitializeReceiver(100, OnMessage, this);
}
public ServerToClientLinkEndpoint(ListenerLink link)
: base(link)
{
}
static void OnMessage(ListenerLink link, Message message, DeliveryState deliveryState, object state)
{
var thisPtr = (TxnManager)state;
object body;
try
{
body = Message.Decode(((BrokerMessage)message).Buffer).Body;
}
catch (Exception exception)
{
Trace.WriteLine(TraceLevel.Error, exception.Message);
link.DisposeMessage(
message,
new Rejected() { Error = new Error() { Condition = ErrorCode.DecodeError, Description = "Cannot decode txn message" } },
true);
return;
}
if (body is Declare)
{
int txnId = thisPtr.CreateTransaction();
var outcome = new Declared() { TxnId = BitConverter.GetBytes(txnId) };
link.DisposeMessage(message, outcome, true);
}
else if (body is Discharge)
{
Discharge discharge = (Discharge)body;
int txnId = BitConverter.ToInt32(discharge.TxnId, 0);
Transaction txn;
if (thisPtr.transactions.TryGetValue(txnId, out txn))
{
lock (thisPtr.transactions)
{
thisPtr.transactions.Remove(txnId);
}
txn.Discharge(discharge.Fail);
link.DisposeMessage(message, new Accepted(), true);
}
else
{
link.DisposeMessage(
message,
new Rejected() { Error = new Error() { Condition = ErrorCode.NotFound, Description = "Transaction not found" } },
true);
}
}
else
{
link.DisposeMessage(
message,
new Rejected() { Error = new Error() { Condition = ErrorCode.NotImplemented, Description = "Unsupported message body" } },
true);
}
}
static void OnMessage(ListenerLink link, Message message, DeliveryState deliveryState, object state)
{
var thisPtr = (TxnManager)state;
object body;
try
{
body = Message.Decode(((BrokerMessage)message).Buffer).Body;
}
catch (Exception exception)
{
Trace.WriteLine(TraceLevel.Error, exception.Message);
link.DisposeMessage(
message,
new Rejected()
{
Error = new Error()
{
Condition = ErrorCode.DecodeError, Description = "Cannot decode txn message"
}
},
true);
return;
}
if (body is Declare)
{
int txnId = thisPtr.CreateTransaction();
var outcome = new Declared()
{
TxnId = BitConverter.GetBytes(txnId)
};
link.DisposeMessage(message, outcome, true);
}
else if (body is Discharge)
{
Discharge discharge = (Discharge)body;
int txnId = BitConverter.ToInt32(discharge.TxnId, 0);
Transaction txn;
if (thisPtr.transactions.TryGetValue(txnId, out txn))
{
lock (thisPtr.transactions)
{
thisPtr.transactions.Remove(txnId);
}
txn.Discharge(discharge.Fail);
link.DisposeMessage(message, new Accepted(), true);
}
else
{
link.DisposeMessage(
message,
new Rejected()
{
Error = new Error()
{
Condition = ErrorCode.NotFound, Description = "Transaction not found"
}
},
true);
}
}
else
{
link.DisposeMessage(
message,
new Rejected()
{
Error = new Error()
{
Condition = ErrorCode.NotImplemented, Description = "Unsupported message body"
}
},
true);
}
}
public override void OnLinkClosed(ListenerLink link, Error error) => CancelFlowTask();
