public void Should_setup_permissions()
{
var testQueueName = "MsmqQueueCreatorTests.permissions";
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
DeleteQueueIfPresent(testQueueName);
bindings.BindReceiving(testQueueName);
// use the network service account since that one won't be in the local admin group
creator.CreateQueueIfNecessary(bindings, NetworkServiceAccountName);
var createdQueue = GetQueue(testQueueName);
MessageQueueAccessRights? accountAccessRights;
Assert.True(createdQueue.TryGetPermissions(NetworkServiceAccountName, out accountAccessRights));
Assert.True(accountAccessRights.HasValue, "User should have access rights");
Assert.AreEqual(MessageQueueAccessRights.WriteMessage | MessageQueueAccessRights.ReceiveMessage, accountAccessRights, "User should have write/read access");
MessageQueueAccessRights? localAdminAccessRights;
Assert.True(createdQueue.TryGetPermissions(LocalAdministratorsGroupName, out localAdminAccessRights));
Assert.True(localAdminAccessRights.HasValue, "User should have access rights");
Assert.AreEqual(MessageQueueAccessRights.FullControl, localAdminAccessRights, "LocalAdmins should have full control");
}
public void Should_not_add_everyone_and_anonymous_to_already_existing_queues()
{
var path = MsmqAddress.Parse(testQueueNameForReceiving).PathWithoutPrefix;
using (var queue = MessageQueue.Create(path))
{
queue.SetPermissions(LocalEveryoneGroupName, MessageQueueAccessRights.GenericWrite, AccessControlEntryType.Revoke);
queue.SetPermissions(LocalAnonymousLogonName, MessageQueueAccessRights.WriteMessage, AccessControlEntryType.Revoke);
}
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueNameForReceiving);
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
var existingQueue = GetQueue(testQueueNameForReceiving);
MessageQueueAccessRights?nullBecauseRevoked;
AccessControlEntryType? accessControlEntryType;
Assert.False(existingQueue.TryGetPermissions(LocalEveryoneGroupName, out nullBecauseRevoked, out accessControlEntryType));
Assert.False(existingQueue.TryGetPermissions(LocalAnonymousLogonName, out nullBecauseRevoked, out accessControlEntryType));
Assert.IsNull(accessControlEntryType);
}
public void Should_setup_permissions()
{
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueNameForReceiving);
// use the network service account since that one won't be in the local admin group
creator.CreateQueueIfNecessary(bindings, NetworkServiceAccountName);
var createdQueue = GetQueue(testQueueNameForReceiving);
MessageQueueAccessRights?accountAccessRights;
AccessControlEntryType? accessControlEntryType;
Assert.True(createdQueue.TryGetPermissions(NetworkServiceAccountName, out accountAccessRights, out accessControlEntryType));
Assert.True(accountAccessRights.HasValue);
Assert.True(accessControlEntryType == AccessControlEntryType.Allow, "User should have access");
Assert.True(accountAccessRights?.HasFlag(MessageQueueAccessRights.WriteMessage), $"{NetworkServiceAccountName} should have write access");
Assert.True(accountAccessRights?.HasFlag(MessageQueueAccessRights.ReceiveMessage), $"{NetworkServiceAccountName} should have receive messages access");
MessageQueueAccessRights?localAdminAccessRights;
AccessControlEntryType? accessControlEntryTypeForLocalAdmin;
Assert.True(createdQueue.TryGetPermissions(LocalAdministratorsGroupName, out localAdminAccessRights, out accessControlEntryTypeForLocalAdmin));
Assert.True(localAdminAccessRights.HasValue);
Assert.True(localAdminAccessRights?.HasFlag(MessageQueueAccessRights.FullControl), $"{LocalAdministratorsGroupName} should have full control");
Assert.IsTrue(accessControlEntryTypeForLocalAdmin == AccessControlEntryType.Allow, $"{LocalAdministratorsGroupName} should have access");
}
public void Should_setup_permissions()
{
var testQueueName = "MsmqQueueCreatorTests.permissions";
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
DeleteQueueIfPresent(testQueueName);
bindings.BindReceiving(testQueueName);
// use the network service account since that one won't be in the local admin group
creator.CreateQueueIfNecessary(bindings, NetworkServiceAccountName);
var createdQueue = GetQueue(testQueueName);
MessageQueueAccessRights?accountAccessRights;
Assert.True(createdQueue.TryGetPermissions(NetworkServiceAccountName, out accountAccessRights));
Assert.True(accountAccessRights.HasValue, "User should have access rights");
Assert.AreEqual(MessageQueueAccessRights.WriteMessage | MessageQueueAccessRights.ReceiveMessage, accountAccessRights, "User should have write/read access");
MessageQueueAccessRights?localAdminAccessRights;
Assert.True(createdQueue.TryGetPermissions(LocalAdministratorsGroupName, out localAdminAccessRights));
Assert.True(localAdminAccessRights.HasValue, "User should have access rights");
Assert.AreEqual(MessageQueueAccessRights.FullControl, localAdminAccessRights, "LocalAdmins should have full control");
}
void PrimeSubscriptionStorage(ISubscriptionStorage subscriptionStorage)
{
var testEventMessage = new MessageType(typeof(TestEvent));
subscriptionStorage.Init();
var creator = new MsmqQueueCreator
{
Settings = new MsmqSettings
{
UseTransactionalQueues = true
}
};
for (var i = 0; i < GetNumberOfSubscribers(); i++)
{
var subscriberAddress = Address.Parse("PubSubPerformanceTest.Subscriber" + i);
creator.CreateQueueIfNecessary(subscriberAddress, null);
using (var tx = new TransactionScope())
{
subscriptionStorage.Subscribe(subscriberAddress, new List <MessageType>
{
testEventMessage
});
tx.Complete();
}
}
}
public void Should_blow_up_if_name_is_null()
{
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(null);
Assert.Throws <ArgumentNullException>(() => creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name));
}
public void Should_blow_up_for_invalid_accounts()
{
var creator = new MsmqQueueCreator(true, "invalidaccount");
var ex = Assert.Throws <InvalidOperationException>(() =>
creator.CreateQueueIfNecessary(new[] { testQueueNameForReceiving }));
StringAssert.Contains("invalidaccount", ex.Message);
}
public void Should_make_queues_non_transactional_if_requested()
{
var creator = new MsmqQueueCreator(false, WindowsIdentity.GetCurrent().Name);
creator.CreateQueueIfNecessary(new[] { testQueueNameForReceiving });
var queue = GetQueue(testQueueNameForReceiving);
Assert.False(queue.Transactional);
}
public void Should_not_create_queue_when_a_remote_queue_is_provided()
{
var remoteQueueName = $"{testQueueNameForReceiving}@some-machine";
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindSending(remoteQueueName);
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
Assert.False(QueueExists(testQueueNameForReceiving));
}
public void Should_not_create_remote_queues()
{
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
var remoteQueueName = "MsmqQueueCreatorTests.remote";
bindings.BindSending($"{remoteQueueName}@some-machine");
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
Assert.False(QueueExists(remoteQueueName));
}
public void Should_not_create_remote_queues()
{
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
var remoteQueueName = "MsmqQueueCreatorTests.remote";
bindings.BindSending($"{remoteQueueName}@some-machine");
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
Assert.False(QueueExists(remoteQueueName));
}
public void Should_create_all_queues()
{
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueNameForReceiving);
bindings.BindSending(testQueueNameForSending);
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
Assert.True(QueueExists(testQueueNameForSending));
Assert.True(QueueExists(testQueueNameForReceiving));
}
public void Should_create_all_queues()
{
var creator = new MsmqQueueCreator(true, WindowsIdentity.GetCurrent().Name);
creator.CreateQueueIfNecessary(new[]
{
testQueueNameForReceiving,
testQueueNameForSending
});
Assert.True(QueueExists(testQueueNameForSending));
Assert.True(QueueExists(testQueueNameForReceiving));
}
public void Should_make_queues_transactional_if_requested()
{
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueNameForReceiving);
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
var queue = GetQueue(testQueueNameForReceiving);
Assert.True(queue.Transactional);
}
public void Should_be_replaced_by_a_deterministic_guid()
{
var address = Address.Parse("WhenSpecifyingAQueuNameWithTotalLengthIncludingMachineNameAndPrivateIdentifierExceeding114Chars@MyMachine");
var path = MsmqQueueCreator.GetFullPathWithoutPrefix(address);
var queueName = path.Replace(@"MyMachine\private$\", "");
var secondPath = MsmqQueueCreator.GetFullPathWithoutPrefix(address);
Guid isAGuid;
Assert.IsTrue(Guid.TryParse(queueName, out isAGuid));
Assert.AreEqual(path, secondPath);
}
public void Should_blow_up_for_invalid_accounts()
{
var testQueueName = "MsmqQueueCreatorTests.badidentity";
DeleteQueueIfPresent(testQueueName);
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueName);
var ex = Assert.Throws <InvalidOperationException>(() => creator.CreateQueueIfNecessary(bindings, "invalidaccount"));
StringAssert.Contains("invalidaccount", ex.Message);
}
public void Should_make_queues_non_transactional_if_requested()
{
var testQueueName = "MsmqQueueCreatorTests.txreceiver";
DeleteQueueIfPresent(testQueueName);
var creator = new MsmqQueueCreator(false);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueName);
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
var queue = GetQueue(testQueueName);
Assert.False(queue.Transactional);
}
public void Should_make_queues_transactional_if_requested()
{
var testQueueName = "MsmqQueueCreatorTests.txreceiver";
DeleteQueueIfPresent(testQueueName);
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueName);
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
var queue = GetQueue(testQueueName);
Assert.True(queue.Transactional);
}
public void Should_allow_queue_names_above_the_limit_for_set_permission()
{
var testQueueName = $"MsmqQueueCreatorTests.tolong.{Guid.NewGuid().ToString().Replace("-", "")}";
var maxQueueNameForSetPermissionToWork = 102 - Environment.MachineName.Length;
testQueueName = $"{testQueueName}{new string('a', maxQueueNameForSetPermissionToWork - testQueueName.Length + 1)}";
DeleteQueueIfPresent(testQueueName);
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueName);
Assert.DoesNotThrow(() => creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name));
}
public void Should_create_all_queues()
{
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
DeleteQueueIfPresent("MsmqQueueCreatorTests.receiver");
DeleteQueueIfPresent("MsmqQueueCreatorTests.endpoint1");
DeleteQueueIfPresent("MsmqQueueCreatorTests.endpoint2");
bindings.BindReceiving("MsmqQueueCreatorTests.receiver");
bindings.BindSending("MsmqQueueCreatorTests.target1");
bindings.BindSending("MsmqQueueCreatorTests.target2");
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
Assert.True(QueueExists("MsmqQueueCreatorTests.receiver"));
Assert.True(QueueExists("MsmqQueueCreatorTests.target1"));
Assert.True(QueueExists("MsmqQueueCreatorTests.target2"));
}
public void Should_create_all_queues()
{
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
DeleteQueueIfPresent("MsmqQueueCreatorTests.receiver");
DeleteQueueIfPresent("MsmqQueueCreatorTests.endpoint1");
DeleteQueueIfPresent("MsmqQueueCreatorTests.endpoint2");
bindings.BindReceiving("MsmqQueueCreatorTests.receiver");
bindings.BindSending("MsmqQueueCreatorTests.target1");
bindings.BindSending("MsmqQueueCreatorTests.target2");
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
Assert.True(QueueExists("MsmqQueueCreatorTests.receiver"));
Assert.True(QueueExists("MsmqQueueCreatorTests.target1"));
Assert.True(QueueExists("MsmqQueueCreatorTests.target2"));
}
public void Should_setup_permissions()
{
// use the network service account since that one won't be in the local admin group
var creator = new MsmqQueueCreator(true, NetworkServiceAccountName);
creator.CreateQueueIfNecessary(new[] { testQueueNameForReceiving });
var createdQueue = GetQueue(testQueueNameForReceiving);
Assert.True(createdQueue.TryGetPermissions(NetworkServiceAccountName, out var accountAccessRights, out var accessControlEntryType));
Assert.True(accountAccessRights.HasValue);
Assert.True(accessControlEntryType == AccessControlEntryType.Allow, "User should have access");
Assert.True(accountAccessRights.Value.HasFlag(MessageQueueAccessRights.WriteMessage), $"{NetworkServiceAccountName} should have write access");
Assert.True(accountAccessRights.Value.HasFlag(MessageQueueAccessRights.ReceiveMessage), $"{NetworkServiceAccountName} should have receive messages access");
Assert.True(accountAccessRights.Value.HasFlag(MessageQueueAccessRights.GetQueueProperties), $"{NetworkServiceAccountName} should have get queue properties access");
Assert.True(createdQueue.TryGetPermissions(LocalAdministratorsGroupName, out var localAdminAccessRights, out var accessControlEntryTypeForLocalAdmin));
Assert.True(localAdminAccessRights.HasValue);
Assert.True(localAdminAccessRights.Value.HasFlag(MessageQueueAccessRights.FullControl), $"{LocalAdministratorsGroupName} should have full control");
Assert.IsTrue(accessControlEntryTypeForLocalAdmin == AccessControlEntryType.Allow, $"{LocalAdministratorsGroupName} should have access");
}
public async Task Should_delete_staging_table_when_empty()
{
await using var connection = new SqlConnection(connectionString);
await connection.OpenAsync();
var sut = new MsmqTarget(new TestLoggingAdapter(), connectionString, schema);
await MsmqQueueCreator.CreateStagingQueue(connection, MsmqSqlConstants.TimeoutMigrationStagingTable, schema, connection.Database, preview : false);
await sut.Complete(ExistingEndpointName);
var sqlStatement = $"SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = 'dbo' AND TABLE_NAME = '{MsmqSqlConstants.TimeoutMigrationStagingTable}' AND TABLE_CATALOG = '{databaseName}'";
await using var command = new SqlCommand(sqlStatement, connection)
{
CommandType = CommandType.Text
};
var result = await command.ExecuteScalarAsync().ConfigureAwait(false) as int?;
Assert.That(result, Is.EqualTo(0));
}
public async Task Should_throw_when_staging_table_not_empty()
{
await using var connection = new SqlConnection(connectionString);
await connection.OpenAsync();
var sut = new MsmqTarget(new TestLoggingAdapter(), connectionString, schema);
await MsmqQueueCreator.CreateStagingQueue(connection, MsmqSqlConstants.TimeoutMigrationStagingTable, schema, connection.Database, preview : false);
var sql =
$"INSERT INTO {schema}.{MsmqSqlConstants.TimeoutMigrationStagingTable} VALUES('id', 'destination', NULL, DATEADD(DAY, 1, GETDATE()), CAST('headers' AS VARBINARY(MAX)), 0)";
await using var command = new SqlCommand(sql, connection)
{
CommandType = CommandType.Text
};
await command.ExecuteNonQueryAsync();
Assert.ThrowsAsync <Exception>(async() =>
{
await sut.Complete(ExistingEndpointName);
});
}
public void Should_not_add_everyone_and_anonymous_to_already_existing_queues()
{
var testQueueName = "MsmqQueueCreatorTests.NoChangesToExisting";
DeleteQueueIfPresent(testQueueName);
var path = MsmqAddress.Parse(testQueueName).PathWithoutPrefix;
using (var existingQueue = MessageQueue.Create(path))
{
existingQueue.SetPermissions(LocalEveryoneGroupName, MessageQueueAccessRights.GenericWrite, AccessControlEntryType.Revoke);
existingQueue.SetPermissions(LocalAnonymousLogonName, MessageQueueAccessRights.WriteMessage, AccessControlEntryType.Revoke);
}
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueName);
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
var queue = GetQueue(testQueueName);
MessageQueueAccessRights? nullBecauseRevoked;
Assert.False(queue.TryGetPermissions(LocalEveryoneGroupName, out nullBecauseRevoked));
Assert.False(queue.TryGetPermissions(LocalAnonymousLogonName, out nullBecauseRevoked));
}
public void Should_allow_queue_names_above_the_limit_for_set_permission()
{
var testQueueName = $"MsmqQueueCreatorTests.tolong.{Guid.NewGuid().ToString().Replace("-", "")}";
var maxQueueNameForSetPermissionToWork = 102 - Environment.MachineName.Length;
testQueueName = $"{testQueueName}{new string('a', maxQueueNameForSetPermissionToWork - testQueueName.Length + 1)}";
DeleteQueueIfPresent(testQueueName);
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueName);
Assert.DoesNotThrow(() => creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name));
}
public void Should_blow_up_for_invalid_accounts()
{
var testQueueName = "MsmqQueueCreatorTests.badidentity";
DeleteQueueIfPresent(testQueueName);
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueName);
var ex = Assert.Throws<InvalidOperationException>(() => creator.CreateQueueIfNecessary(bindings, "invalidaccount"));
StringAssert.Contains("invalidaccount", ex.Message);
}
public void Should_blow_up_if_name_is_null()
{
var creator = new MsmqQueueCreator(true);
var bindings = new QueueBindings();
bindings.BindReceiving(null);
Assert.Throws<ArgumentNullException>(() => creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name));
}
public override void Run()
{
TransportConfigOverride.MaximumConcurrencyLevel = NumberOfThreads;
Feature.Disable <Audit>();
Configure.Transactions.Enable();
var config = Configure.With()
.DefineEndpointName("PubSubPerformanceTest")
.DefaultBuilder()
.UseTransport <Msmq>()
.InMemoryFaultManagement();
switch (GetStorageType())
{
case "raven":
config.RavenSubscriptionStorage();
break;
case "inmemory":
config.InMemorySubscriptionStorage();
break;
case "msmq":
config.MsmqSubscriptionStorage();
break;
}
using (var bus = config.UnicastBus()
.CreateBus())
{
Configure.Instance.ForInstallationOn <NServiceBus.Installation.Environments.Windows>().Install();
var subscriptionStorage = Configure.Instance.Builder.Build <ISubscriptionStorage>();
var testEventMessage = new MessageType(typeof(RavenTestEvent));
subscriptionStorage.Init();
var creator = new MsmqQueueCreator
{
Settings = new MsmqSettings {
UseTransactionalQueues = true
}
};
for (var i = 0; i < GetNumberOfSubscribers(); i++)
{
var subscriberAddress = Address.Parse("PubSubPerformanceTest.Subscriber" + i);
creator.CreateQueueIfNecessary(subscriberAddress, null);
using (var tx = new TransactionScope())
{
subscriptionStorage.Subscribe(subscriberAddress, new List <MessageType>
{
testEventMessage
});
tx.Complete();
}
}
Parallel.For(
0,
NumberMessages,
new ParallelOptions {
MaxDegreeOfParallelism = NumberOfThreads
},
x => bus.SendLocal(new PerformRavenPublish()));
Statistics.StartTime = DateTime.Now;
bus.Start();
while (Interlocked.Read(ref Statistics.NumberOfMessages) < NumberMessages)
{
Thread.Sleep(1000);
}
Statistics.Dump();
}
}
