public RemoteMsmqGrantReadWriteTask(PhysicalServer server, string queueName, string group)
{
_server = server;
_group = group;
var ub = new UriBuilder("msmq", server.Name) { Path = queueName };
_address = new QueueAddress(ub.Uri);
}
public RemoteMsmqGrantAccessRightsTask(PhysicalServer server, QueueAddress address, string user, MessageQueueAccessRights accessRights)
{
_server = server;
_address = address;
_user = user;
_accessRights = accessRights;
}
//dropkick.remote create_queue msmq://servername/dk_remote
//dropkick.remote verify_queue msmq://servername/dk_remote
//dropkick.remote grant [r|w|rw] username msmq://servername/dk_remote
static void Main(string[] args)
{
try
{
if (args[0] == "create_queue")
{
var queuename = args[1];
var queueAddress = new QueueAddress(queuename);
var formattedName = queueAddress.LocalName;
MessageQueue.Create(formattedName);
Environment.Exit(0);
}
else if (args[0] == "verify_queue")
{
var queuename = args[1];
var queueAddress = new QueueAddress(queuename);
var formattedName = queueAddress.LocalName;
var result = MessageQueue.Exists(formattedName);
Console.WriteLine("exists");
Environment.Exit(0);
}
else if (args[0] == "grant")
{
var perm = args[1];
var user = args[2];
var queue = args[3];
var queueAddress = new QueueAddress(queue);
switch (perm)
{
case "r":
new LocalMsmqGrantReadTask(queueAddress, user).Execute();
break;
case "w":
new MsmqGrantWriteTask(queueAddress, user).Execute();
break;
case "rw":
new LocalMsmqGrantReadWriteTask(queueAddress, user).Execute();
break;
case "default":
new SetSensibleMsmqDefaults(queueAddress).Execute();
break;
}
}
}
catch (Exception ex)
{
File.AppendAllText("error.txt", ex.ToString());
Console.WriteLine(ex);
Environment.Exit(21);
}
}
private static DeploymentResult CreateMsmq(string[] args)
{
var queuename = args[1];
var queueAddress = new QueueAddress(queuename);
var transactional = false;
if (args.Length > 2)
bool.TryParse(args[2], out transactional);
var result = new CreateLocalMsmqQueueTask(_server, queueAddress, transactional).Execute();
return result;
}
public DeploymentResult CreateQueue(QueueAddress path)
{
var t = new RemoteCommandLineTask("dropkick.remote.exe")
{
Args = "create_queue {0}".FormatWith(path.ActualUri),
ExecutableIsLocatedAt = @"C:\Temp\dropkick.remote\",
Machine = _server.Name,
WorkingDirectory = @"C:\Temp\dropkick.remote\"
};
return t.Execute();
}
public override void RegisterRealTasks(PhysicalServer site)
{
var uriBuilder = new UriBuilder("msmq", site.Name) { Path = _queue };
var address = new QueueAddress(uriBuilder.Uri);
Task task;
if (site.IsLocal)
task = new LocalMsmqGrantAccessRightsTask(address, _group, _accessRights);
else
task = new RemoteMsmqGrantAccessRightsTask(site, address, _group, _accessRights);
site.AddTask(task);
}
static void TryDeleteTable(SqlConnection conn, QueueAddress address)
{
try
{
using (var comm = conn.CreateCommand())
{
comm.CommandText = $"IF OBJECT_ID('{address.QualifiedTableName}', 'U') IS NOT NULL DROP TABLE {address.QualifiedTableName}";
comm.ExecuteNonQuery();
}
}
catch (Exception e)
{
if (!e.Message.Contains("it does not exist or you do not have permission"))
{
throw;
}
}
}
public void ExecuteLocal()
{
var ps = new DeploymentServer(Environment.MachineName);
var ub = new UriBuilder("msmq", ps.Name)
{
Path = "dk_test2"
};
var address = new QueueAddress(ub.Uri);
if (MessageQueue.Exists(address.LocalName))
{
MessageQueue.Delete(address.LocalName);
}
var t = new CreateLocalMsmqQueueTask(ps, address);
var r = t.Execute();
Assert.IsFalse(r.ContainsError(), "Errors occured during MSMQ create execution.");
}
protected override void Setup(FeatureConfigurationContext context)
{
var endpointQueueName = context.Settings.EndpointQueueName();
var queueAddress = new QueueAddress(endpointQueueName, null, null, "MySatellite");
var satelliteAddress = context.Settings.Get <TransportDefinition>().ToTransportAddress(queueAddress);
context.AddSatelliteReceiver("Test satellite", satelliteAddress, PushRuntimeSettings.Default,
(c, ec) => RecoverabilityAction.MoveToError(c.Failed.ErrorQueue),
(builder, messageContext, cancellationToken) =>
{
var testContext = builder.GetService <Context>();
testContext.MessageReceived = true;
testContext.TransportTransactionAddedToContext = ReferenceEquals(messageContext.Extensions.Get <TransportTransaction>(), messageContext.TransportTransaction);
return(Task.FromResult(true));
});
Address = satelliteAddress;
}
public override void RegisterRealTasks(PhysicalServer site)
{
var uriBuilder = new UriBuilder("msmq", site.Name)
{
Path = _queue
};
var address = new QueueAddress(uriBuilder.Uri);
Task task;
if (site.IsLocal)
{
task = new LocalMsmqGrantAccessRightsTask(address, _group, _accessRights);
}
else
{
task = new RemoteMsmqGrantAccessRightsTask(site, address, _group, _accessRights);
}
site.AddTask(task);
}
/// <inheritdoc />
public override string ToTransportAddress(QueueAddress address)
{
if (!address.Properties.TryGetValue("machine", out var machine))
{
machine = RuntimeEnvironment.MachineName;
}
if (!address.Properties.TryGetValue("queue", out var queueName))
{
queueName = address.BaseAddress;
}
var queue = new StringBuilder(queueName);
if (address.Discriminator != null)
{
queue.Append("-" + address.Discriminator);
}
if (address.Qualifier != null)
{
queue.Append("." + address.Qualifier);
}
return($"{queue}@{machine}");
}
public QueueAddressQueue(QueueAddress queueAddress, IAmazonSQS sqsClient)
{
_client = sqsClient;
Uri = queueAddress.QueueUrl;
var pathSegments = queueAddress.QueueUrl.Segments.Select(x => x.Trim('/')).Where(x => !string.IsNullOrEmpty(x)).ToArray();
if (pathSegments.Length != 2)
{
throw new ArgumentException("Queue Url was not correctly formatted. Path should contain 2 segments.");
}
var region = RegionEndpoint.GetBySystemName(queueAddress.RegionName);
var accountId = pathSegments[0];
var resource = pathSegments[1];
RegionSystemName = region.SystemName;
QueueName = resource;
Arn = new Arn {
Partition = region.PartitionName, Service = "sqs", Region = region.SystemName, AccountId = accountId, Resource = resource
}.ToString();
}
private static DeploymentResult GrantMsmqPermissions(string[] args)
{
var result = new DeploymentResult();
var perm = args[1];
var user = args[2];
var queue = args[3];
var queueAddress = new QueueAddress(queue);
int accessRights;
if (int.TryParse(perm, out accessRights))
{
return(new LocalMsmqGrantAccessRightsTask(queueAddress, user, (MessageQueueAccessRights)accessRights).Execute());
}
switch (perm)
{
case "r":
result = new LocalMsmqGrantReadTask(queueAddress, user).Execute();
break;
case "w":
result = new MsmqGrantWriteTask(queueAddress, user).Execute();
break;
case "rw":
result = new LocalMsmqGrantReadWriteTask(queueAddress, user).Execute();
break;
case "default":
result = new SetSensibleMsmqDefaults(queueAddress).Execute();
break;
}
return(result);
}
public DeploymentResult GrantPermission(QueuePermission permission, QueueAddress address, string @group)
{
string perm;
switch (permission)
{
case QueuePermission.Read:
perm = "r";
break;
case QueuePermission.Write:
perm = "w";
break;
case QueuePermission.ReadWrite:
perm = "rw";
break;
case QueuePermission.SetSensibleDefaults:
perm = "default";
break;
default:
perm = "r";
break;
}
var t = new RemoteCommandLineTask("dropkick.remote.exe")
{
Args = "grant {0} {1} {2}".FormatWith(perm, @group, address.ActualUri),
ExecutableIsLocatedAt = @"C:\Temp\dropkick.remote\",
Machine = _server.Name,
WorkingDirectory = @"C:\Temp\dropkick.remote\"
};
return(t.Execute());
}
protected override void Setup(FeatureConfigurationContext context)
{
var settings = context.Settings;
var configuration = settings.Get <PartitionAwareReceiverSideDistributionConfiguration>();
var discriminator = settings.Get <string>("EndpointInstanceDiscriminator");
var transportInfrastructure = settings.Get <TransportDefinition>();
var logicalAddress = settings.EndpointQueueName();
var supportMessageDrivenPubSub = transportInfrastructure.SupportsPublishSubscribe;
var queueAddress = new QueueAddress(logicalAddress, null, null, null);
var pipeline = context.Pipeline;
if (supportMessageDrivenPubSub)
{
pipeline.Register(new DistributeSubscriptions.Register(discriminator, configuration.Partitions, address => transportInfrastructure.ToTransportAddress(address), queueAddress));
}
var forwarder = new Forwarder(configuration.Partitions, address => transportInfrastructure.ToTransportAddress(address), queueAddress);
pipeline.Register(new DistributeMessagesBasedOnHeader(discriminator, forwarder), "Distributes on the receiver side using header only");
pipeline.Register(new DistributeMessagesBasedOnPayload(discriminator, forwarder, configuration.MapMessageToPartitionKey), "Distributes on the receiver side using user supplied mapper");
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueAddressPublicationBuilder{T}"/> class.
/// </summary>
/// <param name="queueAddress">The address of the queue to publish to.</param>
internal QueueAddressPublicationBuilder(QueueAddress queueAddress)
{
_queueAddress = queueAddress;
}
#pragma warning disable CS0672 // Member overrides obsolete member
public override string ToTransportAddress(QueueAddress address) => MsmqTransportInfrastructure.TranslateAddress(address);
public MsmqGrantWriteTask(QueueAddress address, string group)
{
_group = group;
_address = address;
}
public void Should_generate_address(string tableName, string schemaName, string catalogName, string expectedAddress)
{
var address = new QueueAddress(tableName, schemaName, catalogName);
Assert.AreEqual(expectedAddress, address.Value);
}
public override string ToTransportAddress(QueueAddress address)
{
return(new LearningTransport().ToTransportAddress(address));
}
public SetSensibleMsmqDefaults(QueueAddress path)
{
_address = path;
}
private static DeploymentResult GrantMsmqPermissions(string[] args)
{
DeploymentResult result = new DeploymentResult();
var perm = args[1];
var user = args[2];
var queue = args[3];
var queueAddress = new QueueAddress(queue);
switch (perm)
{
case "r":
result = new LocalMsmqGrantReadTask(queueAddress, user).Execute();
break;
case "w":
result = new MsmqGrantWriteTask(queueAddress, user).Execute();
break;
case "rw":
result = new LocalMsmqGrantReadWriteTask(queueAddress, user).Execute();
break;
case "default":
result = new SetSensibleMsmqDefaults(queueAddress).Execute();
break;
}
return result;
}
public RemoteMsmqGrantReadTask(PhysicalServer server, QueueAddress address, string group)
{
_server = server;
_address = address;
_group = group;
}
private static DeploymentResult GrantMsmqPermissions(string[] args)
{
var result = new DeploymentResult();
var perm = args[1];
var user = args[2];
var queue = args[3];
var queueAddress = new QueueAddress(queue);
int accessRights;
if (int.TryParse(perm, out accessRights))
{
return new LocalMsmqGrantAccessRightsTask(queueAddress, user, (MessageQueueAccessRights)accessRights).Execute();
}
switch (perm)
{
case "r":
result = new LocalMsmqGrantReadTask(queueAddress, user).Execute();
break;
case "w":
result = new MsmqGrantWriteTask(queueAddress, user).Execute();
break;
case "rw":
result = new LocalMsmqGrantReadWriteTask(queueAddress, user).Execute();
break;
case "default":
result = new SetSensibleMsmqDefaults(queueAddress).Execute();
break;
}
return result;
}
public override string ToTransportAddress(QueueAddress address)
{
throw new NotImplementedException();
}
public DeploymentResult GrantPermission(QueuePermission permission, QueueAddress address, string @group)
{
string perm;
switch (permission)
{
case QueuePermission.Read:
perm = "r";
break;
case QueuePermission.Write:
perm = "w";
break;
case QueuePermission.ReadWrite:
perm = "rw";
break;
case QueuePermission.SetSensibleDefaults:
perm = "default";
break;
default:
perm = "r";
break;
}
var t = new RemoteCommandLineTask("dropkick.remote.exe")
{
Args = "grant {0} {1} {2}".FormatWith(perm, @group, address.ActualUri),
ExecutableIsLocatedAt = @"C:\Temp\dropkick.remote\",
Machine = _server.Name,
WorkingDirectory = @"C:\Temp\dropkick.remote\"
};
return t.Execute();
}
private static DeploymentResult VerifyMsmqExists(string[] args)
{
var result = new DeploymentResult();
var queuename = args[1];
var queueAddress = new QueueAddress(queuename);
var formattedName = queueAddress.LocalName;
var exists = MessageQueue.Exists(formattedName);
if (exists) result.AddGood("{0} exists on {1}.".FormatWith(queueAddress.LocalName),_server);
Logging.Coarse("exists");
return result;
}
public CreateRemoteMsmqQueueTask(PhysicalServer server, QueueAddress address)
{
_server = server;
Address = address;
}
public bool VerifyQueue(QueueAddress path)
{
//exe verify_queue path
return(false);
}
public MsmqGrantWriteTask(QueueAddress address, string group)
{
_group = group;
_address = address;
}
public RemoteMsmqGrantReadTask(QueueAddress address, string group)
{
_group = group;
_address = address;
}
public SetSensibleMsmqDefaults(QueueAddress path)
{
_address = path;
}
public CreateRemoteMsmqQueueTask(PhysicalServer server, QueueAddress address)
: this(server, address, false)
{
}
/// <inheritdoc />
public override async Task <TransportInfrastructure> Initialize(HostSettings hostSettings, ReceiveSettings[] receivers, string[] sendingAddresses, CancellationToken cancellationToken = default)
{
Guard.AgainstNull(nameof(hostSettings), hostSettings);
Guard.AgainstNull(nameof(receivers), receivers);
Guard.AgainstNull(nameof(sendingAddresses), sendingAddresses);
CheckMachineNameForCompliance.Check();
ValidateIfDtcIsAvailable();
var queuesToCreate = new HashSet <string>(sendingAddresses);
var requiresDelayedDelivery = DelayedDelivery != null;
string timeoutsErrorQueue = null;
MessagePump delayedDeliveryMessagePump = null;
if (requiresDelayedDelivery)
{
QueueAddress timeoutsQueue;
if (receivers.Length > 0)
{
var mainReceiver = receivers[0];
timeoutsQueue = new QueueAddress(mainReceiver.ReceiveAddress.BaseAddress, qualifier: TimeoutsQueueQualifier);
timeoutsErrorQueue = mainReceiver.ErrorQueue;
}
else
{
if (hostSettings.CoreSettings != null)
{
if (!hostSettings.CoreSettings.TryGetExplicitlyConfiguredErrorQueueAddress(out var coreErrorQueue))
{
throw new Exception("Delayed delivery requires an error queue to be specified using 'EndpointConfiguration.SendFailedMessagesTo()'");
}
timeoutsErrorQueue = coreErrorQueue;
timeoutsQueue = new QueueAddress(hostSettings.Name, qualifier: TimeoutsQueueQualifier); //Use name of the endpoint as the timeouts queue name.
}
else
{
throw new Exception("Timeouts are not supported for send-only configurations outside of an NServiceBus endpoint.");
}
}
delayedDeliveryMessagePump = new MessagePump(mode => SelectReceiveStrategy(mode, TransactionScopeOptions.TransactionOptions),
MessageEnumeratorTimeout, TransportTransactionMode, false, hostSettings.CriticalErrorAction,
new ReceiveSettings("DelayedDelivery", timeoutsQueue, false, false, timeoutsErrorQueue));
queuesToCreate.Add(delayedDeliveryMessagePump.ReceiveAddress);
queuesToCreate.Add(timeoutsErrorQueue);
}
var messageReceivers = CreateReceivers(receivers, hostSettings.CriticalErrorAction, queuesToCreate);
var dispatcher = new MsmqMessageDispatcher(this, delayedDeliveryMessagePump?.ReceiveAddress, OnSendCallbackForTesting);
if (hostSettings.CoreSettings != null)
{
// enforce an explicitly configured error queue when using MSMQ transport with NServiceBus
if (receivers.Length > 0 && !hostSettings.CoreSettings.TryGetExplicitlyConfiguredErrorQueueAddress(out _))
{
throw new Exception("Faults forwarding requires an error queue to be specified using 'EndpointConfiguration.SendFailedMessagesTo()'");
}
bool outBoxRunning = hostSettings.CoreSettings.IsFeatureActive(typeof(Features.Outbox));
if (hostSettings.CoreSettings.TryGetAuditMessageExpiration(out var auditMessageExpiration))
{
TimeToBeReceivedOverrideChecker.Check(
TransportTransactionMode != TransportTransactionMode.None,
outBoxRunning,
auditMessageExpiration > TimeSpan.Zero);
}
if (CreateQueuesForUser == null)
{
// try to use the configured installer user in Core:
CreateQueuesForUser = hostSettings.CoreSettings.GetOrDefault <string>("Installers.UserName");
}
}
if (hostSettings.SetupInfrastructure && CreateQueues)
{
var installerUser = GetInstallationUserName();
var queueCreator = new MsmqQueueCreator(UseTransactionalQueues, installerUser);
if (requiresDelayedDelivery)
{
await DelayedDelivery.DelayedMessageStore.Initialize(hostSettings.Name, TransportTransactionMode, cancellationToken).ConfigureAwait(false);
}
queueCreator.CreateQueueIfNecessary(queuesToCreate);
}
foreach (var address in sendingAddresses.Concat(messageReceivers.Select(r => r.Value.ReceiveAddress)))
{
QueuePermissions.CheckQueue(address);
}
DelayedDeliveryPump delayedDeliveryPump = null;
if (requiresDelayedDelivery)
{
QueuePermissions.CheckQueue(delayedDeliveryMessagePump.ReceiveAddress);
QueuePermissions.CheckQueue(timeoutsErrorQueue);
var staticFaultMetadata = new Dictionary <string, string>
{
{ Headers.ProcessingMachine, RuntimeEnvironment.MachineName },
{ Headers.ProcessingEndpoint, hostSettings.Name },
{ Headers.HostDisplayName, hostSettings.HostDisplayName }
};
var dueDelayedMessagePoller = new DueDelayedMessagePoller(dispatcher, DelayedDelivery.DelayedMessageStore, DelayedDelivery.NumberOfRetries, hostSettings.CriticalErrorAction, timeoutsErrorQueue, staticFaultMetadata, TransportTransactionMode,
DelayedDelivery.TimeToTriggerFetchCircuitBreaker,
DelayedDelivery.TimeToTriggerDispatchCircuitBreaker,
DelayedDelivery.MaximumRecoveryFailuresPerSecond,
delayedDeliveryMessagePump.ReceiveAddress);
delayedDeliveryPump = new DelayedDeliveryPump(dispatcher, dueDelayedMessagePoller, DelayedDelivery.DelayedMessageStore, delayedDeliveryMessagePump, timeoutsErrorQueue, DelayedDelivery.NumberOfRetries, hostSettings.CriticalErrorAction, DelayedDelivery.TimeToTriggerStoreCircuitBreaker, staticFaultMetadata, TransportTransactionMode);
}
hostSettings.StartupDiagnostic.Add("NServiceBus.Transport.MSMQ", new
{
ExecuteInstaller = CreateQueues,
UseDeadLetterQueue,
UseConnectionCache,
UseTransactionalQueues,
UseJournalQueue,
UseDeadLetterQueueForMessagesWithTimeToBeReceived,
TimeToReachQueue = GetFormattedTimeToReachQueue(TimeToReachQueue),
TimeoutQueue = delayedDeliveryMessagePump?.ReceiveAddress,
TimeoutStorageType = DelayedDelivery?.DelayedMessageStore?.GetType(),
});
var infrastructure = new MsmqTransportInfrastructure(messageReceivers, dispatcher, delayedDeliveryPump);
await infrastructure.Start(cancellationToken).ConfigureAwait(false);
return(infrastructure);
}
public MsmqGrantWriteTask(PhysicalServer server, QueueAddress address, string group)
{
_server = server;
_address = address;
_group = group;
}
public CreateRemoteMsmqQueueTask(PhysicalServer server, QueueAddress address, bool transactional)
{
_server = server;
Address = address;
_transactional = transactional;
}
public SetSensibleMsmqDefaults(PhysicalServer server, QueueAddress path)
{
_server = server;
_address = path;
}
public static DeploymentResult GrantMsmqPermission(this RemoteDropkickExecutionTask remoteTask, QueuePermission permission, QueueAddress address, string @group)
{
string perm;
switch (permission)
{
case QueuePermission.Read:
perm = "r";
break;
case QueuePermission.Write:
perm = "w";
break;
case QueuePermission.ReadWrite:
perm = "rw";
break;
case QueuePermission.SetSensibleDefaults:
perm = "default";
break;
default:
perm = "r";
break;
}
var t = remoteTask.SetUpRemote("grant_queue {0} {1} {2}".FormatWith(perm, @group, address.ActualUri));
return(remoteTask.ExecuteAndGetResults(t));
}
public SetSensibleMsmqDefaults(PhysicalServer server, QueueAddress path)
{
_server = server;
_address = path;
}
public LocalMsmqGrantReadTask(QueueAddress address, string group)
{
_group = group;
_address = address;
}
public MsmqGrantWriteTask(PhysicalServer server, QueueAddress address, string group)
{
_server = server;
_address = address;
_group = group;
}
public CreateLocalMsmqQueueTask(PhysicalServer server, string queueName)
{
_server = server;
var ub = new UriBuilder("msmq", server.Name) { Path = queueName };
Address = new QueueAddress(ub.Uri);
}
public async Task <TransportInfrastructure> Configure(TransportDefinition transportDefinition, HostSettings hostSettings, QueueAddress inputQueueName, string errorQueueName, CancellationToken cancellationToken = default)
{
var msmqSettings = (MsmqTransport)transportDefinition;
var infrastructure = await msmqSettings.Initialize(hostSettings,
new[] { new ReceiveSettings("TestReceiver", inputQueueName, false, true, errorQueueName) },
new[] { errorQueueName },
cancellationToken);
receiveQueue = infrastructure.ToTransportAddress(inputQueueName);
return(infrastructure);
}
public RemoteMsmqGrantReadWriteTask(PhysicalServer server, QueueAddress address, string group)
{
_server = server;
_group = group;
_address = address;
}
public CreateLocalMsmqQueueTask(PhysicalServer server, QueueAddress address)
: this(server, address, false)
{
}
public async Task <TransportInfrastructure> Configure(TransportDefinition transportDefinition, HostSettings hostSettings, QueueAddress inputQueue, string errorQueueName, CancellationToken cancellationToken = default)
{
var mainReceiverSettings = new ReceiveSettings(
"mainReceiver",
inputQueue,
true,
true, errorQueueName);
var transport = await transportDefinition.Initialize(hostSettings, new[] { mainReceiverSettings }, new[] { errorQueueName }, cancellationToken);
queuesToCleanUp = new[] { transport.ToTransportAddress(inputQueue), errorQueueName };
return(transport);
}
public LocalMsmqGrantAccessRightsTask(QueueAddress address, string user, MessageQueueAccessRights accessRights)
{
_accessRights = accessRights;
_address = address;
_user = user;
}
public CreateLocalMsmqQueueTask(PhysicalServer server, QueueAddress address, bool transactional)
{
_server = server;
Address = address;
_transactional = transactional;
}
public static DeploymentResult CreateQueue(this RemoteDropkickExecutionTask remoteTask, QueueAddress path, bool transactional = false)
{
var t = remoteTask.SetUpRemote("create_queue {0} {1}".FormatWith(path.ActualUri, transactional));
return(remoteTask.ExecuteAndGetResults(t));
}
public bool VerifyQueue(QueueAddress path)
{
//exe verify_queue path
return false;
}
public static DeploymentResult VerifyQueueExists(this RemoteDropkickExecutionTask remoteTask, QueueAddress path)
{
var t = remoteTask.SetUpRemote("verify_queue {0}".FormatWith(path.ActualUri));
return(remoteTask.ExecuteAndGetResults(t));
}
public Forwarder(HashSet <string> knownPartitionKeys, Func <QueueAddress, string> addressTranslator, QueueAddress logicalAddress)
{
this.knownPartitionKeys = knownPartitionKeys;
this.addressTranslator = addressTranslator;
this.logicalAddress = logicalAddress;
}
