static void Main()
{
_servicesBusConnectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.ServiceBus);
namespaceManager = NamespaceManager.CreateFromConnectionString(_servicesBusConnectionString);
if (!namespaceManager.QueueExists(nameof(Step1)))
{
namespaceManager.CreateQueue(nameof(Step1));
}
if (!namespaceManager.QueueExists(nameof(Step2)))
{
namespaceManager.CreateQueue(nameof(Step2));
}
JobHostConfiguration config = new JobHostConfiguration();
config.UseServiceBus();
var host = new JobHost(config);
CreateStartMessage();
host.RunAndBlock();
}
protected internal void StartQueues(Dictionary <Type, IMessageHandlerFactory> handlerMap)
{
// Create queues for each registered type
this.handlerMap = handlerMap;
queueMap = new Dictionary <string, Type>();
var mqSuffixes = new [] { ".inq", ".outq", ".priorityq", ".dlq" };
foreach (var type in this.handlerMap.Keys)
{
foreach (var mqSuffix in mqSuffixes)
{
var queueName = QueueNames.ResolveQueueNameFn(type.Name, mqSuffix);
if (!queueMap.ContainsKey(queueName))
{
queueMap.Add(queueName, type);
}
#if !NETSTANDARD2_0
var mqDesc = new QueueDescription(queueName);
if (!namespaceManager.QueueExists(queueName))
{
namespaceManager.CreateQueue(mqDesc);
}
#endif
}
var mqNames = new QueueNames(type);
AddQueueHandler(mqNames.In);
AddQueueHandler(mqNames.Priority);
}
}
private void InitializeStorage()
{
// Open storage account using credentials from .cscfg file.
var storageAccount = CloudStorageAccount.Parse
(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString"));
//Trace.TraceInformation("Creating InputDocuments blob container");
var blobClient = storageAccount.CreateCloudBlobClient();
var inputBlobContainer = blobClient.GetContainerReference("inputdocuments");
if (inputBlobContainer.CreateIfNotExists())
{
inputBlobContainer.SetPermissions(
new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
}
var outputBlobContainer = blobClient.GetContainerReference("outputdocuments");
if (outputBlobContainer.CreateIfNotExists())
{
outputBlobContainer.SetPermissions(
new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
}
// Thread-safe. Recommended that you cache rather than recreating it
// on every request.
// Obtain these values from the portal.
var Namespace = "pratyay";
var uri = ServiceBusEnvironment.CreateServiceUri("sb", Namespace, string.Empty);
var tP = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey",
"zT1+iZ/5mfikMpLrZXB+FbPelZ6GzqUqCBVbtVc3wtw=");
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.Http;
// Create the namespace manager which gives you access to
// management operations.
var namespaceManager = new NamespaceManager(uri, tP);
// Create the queue if it does not exist already.
if (!namespaceManager.QueueExists("conversionrequest"))
{
namespaceManager.CreateQueue("conversionrequest");
}
if (!namespaceManager.QueueExists("processedmessage"))
{
namespaceManager.CreateQueue("processedmessage");
}
//Trace.TraceInformation("Storage initialized");
}
public void CreateInfoListener(string queueName)
{
if (!_namespaceManager.QueueExists(queueName))
{
_namespaceManager.CreateQueue(queueName);
}
var client = QueueClient.CreateFromConnectionString(_cnString, queueName, ReceiveMode.ReceiveAndDelete);
client.OnMessage(message =>
{
ProcessMsg(message.GetBody <DownloadFileMsg>());
});
}
public ServiceBusQueue(string connectionString, string queueName = null, int retries = 2, int workItemTimeoutMilliseconds = 60 * 1000, bool shouldRecreate = false, RetryPolicy retryPolicy = null)
{
_queueName = queueName ?? typeof(T).Name;
_namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (_namespaceManager.QueueExists(_queueName) && shouldRecreate)
{
_namespaceManager.DeleteQueue(_queueName);
}
if (!_namespaceManager.QueueExists(_queueName))
{
_queueDescription = new QueueDescription(_queueName)
{
MaxDeliveryCount = retries + 1,
LockDuration = TimeSpan.FromMilliseconds(workItemTimeoutMilliseconds)
};
_namespaceManager.CreateQueue(_queueDescription);
}
else
{
_queueDescription = _namespaceManager.GetQueue(_queueName);
_queueDescription.MaxDeliveryCount = retries + 1;
_queueDescription.LockDuration = TimeSpan.FromMilliseconds(workItemTimeoutMilliseconds);
}
_queueClient = QueueClient.CreateFromConnectionString(connectionString, _queueDescription.Path);
if (retryPolicy != null)
{
_queueClient.RetryPolicy = retryPolicy;
}
}
public static void Main(string[] args)
{
ServiceNamespace = ConfigurationManager.AppSettings["ServiceNamespace"];
// Issuer key
sasKeyValue = ConfigurationManager.AppSettings["SASKey"];
// Create management credentials
TokenProvider credentials = TokenProvider.CreateSharedAccessSignatureTokenProvider(sasKeyName, sasKeyValue);
NamespaceManager namespaceClient =
new NamespaceManager(
ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, string.Empty),
credentials);
QueueDescription myQueue;
if (!namespaceClient.QueueExists(QUEUE))
{
myQueue = namespaceClient.CreateQueue(QUEUE);
}
MessagingFactory factory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, string.Empty), credentials);
QueueClient myQueueClient = factory.CreateQueueClient(QUEUE);
// Send message
Poco poco = new Poco();
poco.Id = "001";
poco.content = "This is some content";
BrokeredMessage message = new BrokeredMessage();
message.Properties.Add("Id", poco.Id);
message.Properties.Add("Content", poco.content);
myQueueClient.Send(message);
}
public void CreateQueue(
string path,
bool requiresDuplicateDetection = false,
TimeSpan?duplicateDetectionHistoryTimeWindow = null,
bool requiresSession = false,
int maxDeliveryCount = 10,
TimeSpan?defaultMessageTTL = null,
bool enableDeadLetteringOnMessageExpiration = false
)
{
try
{
QueueDescription queueDescription = new QueueDescription(path)
{
RequiresDuplicateDetection = requiresDuplicateDetection,
DuplicateDetectionHistoryTimeWindow = duplicateDetectionHistoryTimeWindow ?? TimeSpan.FromHours(1),
RequiresSession = requiresSession,
MaxDeliveryCount = maxDeliveryCount,
DefaultMessageTimeToLive = defaultMessageTTL ?? TimeSpan.FromHours(1),
EnableDeadLetteringOnMessageExpiration = enableDeadLetteringOnMessageExpiration
};
if (!_servicebusNamespaceManager.QueueExists(path))
{
_servicebusNamespaceManager.CreateQueue(queueDescription);
}
}
catch (Exception ex)
{
new NotImplementedException();
}
}
public bool Create(IDictionary <string, object> apiRequestModel)
{
bool result = false;
if (null != apiRequestModel)
{
QueueModel queueRequest = apiRequestModel.ToEntity <QueueModel>();
if (null != queueRequest)
{
Logger.LogMessage(string.Format("Checking if queue with name {0} already exists in service bus namespace...", queueRequest.Name));
if (!CheckIfExists(queueRequest.Name))
{
Logger.LogMessage(string.Format(CultureInfo.InvariantCulture, "Creating queue with name {0} in service bus namespace", queueRequest.Name));
QueueDescription queueDescription = GenerateQueueDescription(queueRequest);
if (null != queueDescription)
{
Logger.LogMessage(string.Format(CultureInfo.InvariantCulture, "Creating queue with name {0} in service bus namespace...", queueRequest.Name));
nameSpaceManager.CreateQueue(queueDescription);
Logger.LogMessage(string.Format(CultureInfo.InvariantCulture, "Queue with name {0} created in service bus namespace", queueRequest.Name));
result = true;
}
}
}
}
return(result);
}
public void CreateQueue(string address)
{
if (DoNotCreateQueuesEnabled)
{
_log.Info("Transport configured to not create queue - skipping existencecheck and potential creation");
return;
}
if (_namespaceManager.QueueExists(address))
{
return;
}
var queueDescription = new QueueDescription(address)
{
MaxSizeInMegabytes = 1024,
MaxDeliveryCount = 100,
LockDuration = _peekLockDuration,
EnablePartitioning = PartitioningEnabled
};
try
{
_log.Info("Input queue '{0}' does not exist - will create it now", _inputQueueAddress);
_namespaceManager.CreateQueue(queueDescription);
_log.Info("Created!");
}
catch (MessagingEntityAlreadyExistsException)
{
// fair enough...
_log.Info("MessagingEntityAlreadyExistsException - carrying on");
}
}
public void CreateQueue(string address)
{
if (_namespaceManager.QueueExists(address))
{
return;
}
var queueDescription = new QueueDescription(address)
{
MaxSizeInMegabytes = 1024,
MaxDeliveryCount = 100,
LockDuration = _peekLockDuration,
};
try
{
_log.Info("Input queue '{0}' does not exist - will create it now", _inputQueueAddress);
_namespaceManager.CreateQueue(queueDescription);
_log.Info("Created!");
}
catch (MessagingEntityAlreadyExistsException)
{
// fair enough...
_log.Info("MessagingEntityAlreadyExistsException - carrying on");
}
}
public void CreateQueueIfDoesntExist(string queueName)
{
if (!namespaceManager.QueueExists(queueName))
{
namespaceManager.CreateQueue(queueName);
}
}
public void CreateQueue(string queueName)
{
if (_manager == null)
{
throw new TransportException(_address.Uri, "The namespace manager is not available");
}
if (_manager.QueueExists(queueName))
{
return;
}
var description = new QueueDescription(queueName)
{
DefaultMessageTimeToLive = _address.DefaultMessageTimeToLive,
EnableBatchedOperations = _address.EnableBatchOperations,
LockDuration = _address.LockDuration,
MaxDeliveryCount = _address.MaxDeliveryCount,
};
try
{
_manager.CreateQueue(description);
}
catch (MessagingEntityAlreadyExistsException)
{
}
}
public bool Create()
{
bool result = true;
try
{
Logger.LogMessage("Creating service bus queue...");
Logger.LogMessage("Please provide the name for queue: ");
Name = Console.ReadLine();
Logger.LogMessage(string.Format("Checking if queue with name {0} already exists in service bus namespace...", Name));
if (!CheckIfExists(Name))
{
Logger.LogMessage(string.Format(CultureInfo.InvariantCulture, "Creating queue with name {0} in service bus namespace", Name));
// Generate queue description
QueueDescription queueDescription = GenerateQueueDescription(Name);
// Create queue
Logger.LogMessage(string.Format(CultureInfo.InvariantCulture, "Creating queue with name {0} in service bus namespace...", Name));
nameSpaceManager.CreateQueue(queueDescription);
Logger.LogMessage(string.Format(CultureInfo.InvariantCulture, "Queue with name {0} created in service bus namespace", Name));
}
else
{
result = false;
}
}
catch
{
result = false;
throw;
}
return(result);
}
// Put: api/ReportGenerate
public void Put(ReportRequest req)
{
string queuePath = CloudConfigurationManager.GetSetting("queuePath");
string queueConnectionString = CloudConfigurationManager.GetSetting("queueConnectionString");
NamespaceManager nsm = NamespaceManager.CreateFromConnectionString(queueConnectionString);
//create queue if it doesn't exist
if (!nsm.QueueExists(queuePath))
{
Trace.TraceInformation("Creating queue: {0}...", queuePath);
QueueDescription qd = new QueueDescription(queuePath);
qd.RequiresDuplicateDetection = true; //this can't be changed later
qd = nsm.CreateQueue(qd);
Trace.TraceInformation("Queue created.");
}
//insert the Path to the queue
QueueClient queueClient = QueueClient.CreateFromConnectionString(queueConnectionString, queuePath);
BrokeredMessage bm = new BrokeredMessage();
bm.Properties.Add("reportReq", req.Path);
Trace.TraceInformation("Sending report gen request: {0}", req.Path);
queueClient.Send(bm);
Trace.TraceInformation("Request queued.");
queueClient.Close();
}
public AzureServiceBusMessageQueue ResetQueue()
{
namespaceManager.DeleteQueue(InputQueue);
namespaceManager.CreateQueue(InputQueue);
return(this);
}
//static Mutex mutex;
public MessageQueueHandler(string erpOrThunder, string messageType)
{
//mutex = new Mutex(true, "PERL");
CloudSetQueueConnectionData(erpOrThunder, messageType);
client = QueueClient.CreateFromConnectionString(cloudServiceBusConnectionString, queueName);
serializer = new JsonSerializer()
{
TypeNameHandling = TypeNameHandling.All,
TypeNameAssemblyFormat = FormatterAssemblyStyle.Simple,
ObjectCreationHandling = ObjectCreationHandling.Replace,
ContractResolver = new JsonPrivateSetterPropertyContractResolver(),
DateFormatHandling = DateFormatHandling.IsoDateFormat,
DateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind,
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
};
serializer.Converters.Add(new IsoDateTimeConverter());
try
{
namespaceManager = NamespaceManager.CreateFromConnectionString(cloudServiceBusConnectionString);
if (!namespaceManager.QueueExists(queueName))
{
namespaceManager.CreateQueue(queueName);
}
}
catch (Exception)
{
}
}
static void Main(string[] args)
{
NamespaceManager manager = NamespaceManager.Create(); // Automatycznie bierze informacje z App.config
Console.WriteLine(manager.Address.ToString());
//Wolę na początku - wygodniej "zaczynamy" zawsze od zera
manager.DeleteTopic("2016obliczenia"); //Kasuje temat i subskrypcje
manager.DeleteQueue("2016wynik");
//Tworzenie Topics - tematu
TopicDescription td = new TopicDescription("2016obliczenia");
//Nie przewidujemy dużego ruchu nie wymagamy partycjonowania
td.EnablePartitioning = false;
//Wymagamy wykrywania duplikatów - by klient 2 razy nie wysłał tego samego polecenia
td.RequiresDuplicateDetection = true;
//Nie pozwalamy na tematy tylko w pamięci; chcemy żeby klient był pewien że wysłał wiadomość = wiadomość zostanie przetworzona
td.EnableExpress = false;
manager.CreateTopic(td); //Tworzenie tematu
//Suma i średnia będzie wyliczana gdy opowiednia własciwość zostanie zdefiniowana
manager.CreateSubscription("2016obliczenia", "log", new SqlFilter("1=1"));
manager.CreateSubscription("2016obliczenia", "dodaj", new SqlFilter("operation=1"));
manager.CreateSubscription("2016obliczenia", "odejmij", new SqlFilter("operation=2"));
QueueDescription qd = new QueueDescription("2016wynik");
qd.RequiresSession = true;
manager.CreateQueue(qd);
Console.WriteLine("Done, Enter");
Console.ReadLine();
}
public void CreateQueue(string address)
{
if (_namespaceManager.QueueExists(address))
{
return;
}
var queueDescription = new QueueDescription(address)
{
MaxSizeInMegabytes = 1024,
MaxDeliveryCount = 100,
LockDuration = _peekLockDuration,
EnablePartitioning = PartitioningEnabled,
UserMetadata = string.Format("Created by Rebus {0:yyyy-MM-dd} - {0:HH:mm:ss}", DateTime.Now)
};
try
{
_log.Info("Queue '{0}' does not exist - will create it now", address);
_namespaceManager.CreateQueue(queueDescription);
_log.Info("Created!");
}
catch (MessagingEntityAlreadyExistsException)
{
// fair enough...
_log.Info("MessagingEntityAlreadyExistsException - carrying on");
}
}
public void Publish <TCommand>(TCommand command) where TCommand : ICommand
{
if (command.Id == default(Guid))
{
throw new CommandMissingIdException();
}
string connectionString = CloudConfigurationManager.GetSetting(Settings.Bus.ConfigKey);
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.QueueExists(Settings.Bus.Queue.SendCommand))
{
_Logger.InfoFormat("Queue does not exist creating queue {0}", Settings.Bus.Queue.SendCommand);
QueueDescription queueDescription = namespaceManager.CreateQueue(Settings.Bus.Queue.SendCommand);
}
QueueClient Client = QueueClient.CreateFromConnectionString(connectionString, Settings.Bus.Queue.SendCommand);
DataContractJsonSerializer serializer = JsonSerializerFactory.Create(command);
BrokeredMessage message = new BrokeredMessage(command, serializer)
{
MessageId = command.Id.ToString()
};
_Logger.DebugFormat("Dispatching message with id {0}", message.MessageId);
_JobService.New(command);
Client.SendAsync(message);
}
private void CreateStartMessage(string serviceBusConnectionString)
{
string queueName = ResolveName(StartQueueName);
if (!_namespaceManager.QueueExists(queueName))
{
_namespaceManager.CreateQueue(queueName);
}
QueueClient queueClient = QueueClient.CreateFromConnectionString(serviceBusConnectionString, queueName);
using (Stream stream = new MemoryStream())
using (TextWriter writer = new StreamWriter(stream))
{
writer.Write("E2E");
writer.Flush();
stream.Position = 0;
queueClient.Send(new BrokeredMessage(stream)
{
ContentType = "text/plain"
});
}
queueClient.Close();
}
/// <summary>
/// Creates a queue on the service bus, if the queue doesn't already exists
/// </summary>
/// <param name="namespaceManager">Service Bus namespace Manager that'll handle creation of the queue</param>
/// /// <param name="queueName">The name of the queue to check for and create if not present</param>
private static void RegisterQueue(NamespaceManager namespaceManager, string queueName)
{
if (namespaceManager == null)
{
throw new ArgumentNullException(nameof(namespaceManager));
}
if (string.IsNullOrWhiteSpace(queueName))
{
throw new ArgumentNullException(nameof(queueName));
}
if (namespaceManager.QueueExists(queueName))
{
return;
}
//Queue doesn't exist so create it
var qd = new QueueDescription(queueName)
{
MaxSizeInMegabytes = 1024,
DefaultMessageTimeToLive = TimeSpan.FromMinutes(5)
};
namespaceManager.CreateQueue(qd);
}
// This method will create a queue "sampleQueues/contosoQ" with 2 shared access authorization rules
// for the Listen & Send rights. It uses SharedAccessSignature auth to create the queue and manage the
// authorization rules for the queue.
public static void CreateSASRuleOnEntity(string serviceNamespace, string qPath, string keyName, string key)
{
// Create an instance of NamespaceManager for the operation
Uri managementUri = ServiceBusEnvironment.CreateServiceUri("https", serviceNamespace, string.Empty);
TokenProvider sasTP = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, key);
NamespaceManager nsm = new NamespaceManager(managementUri, sasTP);
QueueDescription qd = new QueueDescription(qPath);
// Setup a rule with send rights with keyName as "contosoQSendKey"
// and add it to the queue description.
Program.contosoQSendRule = new SharedAccessAuthorizationRule("contosoQSendKey",
SharedAccessAuthorizationRule.GenerateRandomKey(),
new[] { AccessRights.Send });
qd.Authorization.Add(Program.contosoQSendRule);
// Setup a rule with listen rights with keyName as "contosoQListenKey"
// and add it to the queue description.
Program.contosoQListenRule = new SharedAccessAuthorizationRule("contosoQListenKey",
SharedAccessAuthorizationRule.GenerateRandomKey(),
new[] { AccessRights.Listen });
qd.Authorization.Add(Program.contosoQListenRule);
// Setup a rule with manage rights with keyName as "contosoQManageKey"
// and add it to the queue description.
// A rule with the Manage right MUST also have the Send & Receive rights.
Program.contosoQManageRule = new SharedAccessAuthorizationRule("contosoQManageKey",
SharedAccessAuthorizationRule.GenerateRandomKey(),
new[] { AccessRights.Manage, AccessRights.Listen, AccessRights.Send });
qd.Authorization.Add(Program.contosoQManageRule);
// Create the queue.
nsm.CreateQueue(qd);
}
public void CreateIfNotExists()
{
if (!Exists())
{
_namespaceManager.CreateQueue(QueueName);
}
}
public void Init(Address address, bool transactional)
{
try
{
queueName = address.Queue;
var description = new QueueDescription(queueName)
{
LockDuration = LockDuration,
MaxSizeInMegabytes = MaxSizeInMegabytes,
RequiresDuplicateDetection = RequiresDuplicateDetection,
RequiresSession = RequiresSession,
DefaultMessageTimeToLive = DefaultMessageTimeToLive,
EnableDeadLetteringOnMessageExpiration = EnableDeadLetteringOnMessageExpiration,
DuplicateDetectionHistoryTimeWindow = DuplicateDetectionHistoryTimeWindow,
MaxDeliveryCount = MaxDeliveryCount,
EnableBatchedOperations = EnableBatchedOperations
};
namespaceClient.CreateQueue(description);
}
catch (MessagingEntityAlreadyExistsException)
{
// the queue already exists, which is ok
}
queueClient = factory.CreateQueueClient(queueName, ReceiveMode.PeekLock);
useTransactions = transactional;
}
private static void InitializeQueue()
{
if (!_namespaceManager.QueueExists(Constants.ExpenseQueue))
{
_namespaceManager.CreateQueue(Constants.ExpenseQueue);
}
}
void CreateQueue(NamespaceManager namespaceManager, Uri serviceUri, string queueName)
{
if (namespaceManager == null)
{
throw new TransportException(serviceUri, "The namespace manager is not available");
}
var description = new QueueDescription(queueName)
{
DefaultMessageTimeToLive = TimeSpan.FromDays(365),
EnableBatchedOperations = true,
LockDuration = TimeSpan.FromMinutes(5),
MaxDeliveryCount = 5,
EnableDeadLetteringOnMessageExpiration = true,
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(10),
};
try
{
var queueDescription = namespaceManager.CreateQueue(description);
}
catch (MessagingEntityAlreadyExistsException)
{
}
}
public void TestGetQueues()
{
string name = "TestGetQueues";
NamespaceManager ns = NamespaceManager.CreateFromConnectionString(serviceBusConnectionString);
QueueDescription description = ns.CreateQueue(name);
Assert.IsTrue(null != description);
try
{
QueueDescription testQueue = ns.GetQueues().FirstOrDefault(e => e.Path.Equals(name, StringComparison.InvariantCultureIgnoreCase));
Assert.IsNotNull(testQueue);
if (!ns.QueueExists(name, out description))
{
Assert.Fail("Queue did not exist");
}
else
{
Assert.IsTrue(null != description);
}
}
finally
{
ns.DeleteQueue(name);
if (ns.QueueExists(name, out description))
{
Assert.Fail("Queue was not deleted");
}
}
}
private QueueClient CreateQueueClient(string queueName)
{
if (!_namespaceManager.QueueExists(queueName))
{
_namespaceManager.CreateQueue(queueName);
}
return(_messageFactory.CreateQueueClient(queueName));
}
public void CreateQueue(string queuePath)
{
Console.Write("\tCreating queue: {0}...", queuePath);
var description = GetQueueDescription(queuePath);
var createDescription = m_NamespaceManager.CreateQueue(description);
Console.WriteLine("Done!");
}
protected void EnsureQueue()
{
if (!NamespaceManager.QueueExists(Name))
{
NamespaceManager.CreateQueue(Name);
queueValidated = true;
}
}
static UtilityBus()
{
spaceManager = NamespaceManager.CreateFromConnectionString(ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]);
if (!spaceManager.QueueExists(ConfigurationManager.AppSettings["QueueName"]))
{
spaceManager.CreateQueue(ConfigurationManager.AppSettings["QueueName"]);
}
}
static void Main()
{
string queueNameDupDection = "RemoveDuplicatesQueue";
string queueNameNoDupDection = "DefaultQueue";
GetUserCredentials();
// Get ServiceBusNamespaceClient for management operations
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(serviceBusConnectionString);
// 1. Create a queue without duplicate detection enabled
Console.WriteLine("\nCreating {0} ...", queueNameNoDupDection);
if (namespaceManager.QueueExists(queueNameNoDupDection))
{
namespaceManager.DeleteQueue(queueNameNoDupDection);
}
namespaceManager.CreateQueue(queueNameNoDupDection);
Console.WriteLine("Created {0}", queueNameNoDupDection);
// Get messageFactory for runtime operation
MessagingFactory messagingFactory = MessagingFactory.CreateFromConnectionString(serviceBusConnectionString);
SendReceive(messagingFactory, queueNameNoDupDection);
// 2. Create a queue with duplicate detection enabled
Console.WriteLine("\nCreating {0} ...", queueNameDupDection);
if (namespaceManager.QueueExists(queueNameDupDection))
{
namespaceManager.DeleteQueue(queueNameDupDection);
}
namespaceManager.CreateQueue(new QueueDescription(queueNameDupDection)
{
RequiresDuplicateDetection = true
});
Console.WriteLine("Created {0}", queueNameDupDection);
SendReceive(messagingFactory, queueNameDupDection);
Console.WriteLine("\nPress [Enter] to exit.");
Console.ReadLine();
// Cleanup:
namespaceManager.DeleteQueue(queueNameDupDection);
namespaceManager.DeleteQueue(queueNameNoDupDection);
}
//Queue and its credentials in another project, this never called
static void CreateQueue()
{
// Create management credentials
TokenProvider credentials = TokenProvider.CreateSharedAccessSignatureTokenProvider(manageKeyName, manageKeyValue);
NamespaceManager namespaceClient = new NamespaceManager(ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, string.Empty), credentials);
QueueDescription myQueue = namespaceClient.CreateQueue("MyQueue");
}
static void CreateQueue(Uri baseAddress,string queueName,QueueDescription queueDescription,TokenProvider credentials)
{
if(QueueExists(baseAddress,queueName,credentials))
{
DeleteQueue(baseAddress,queueName,credentials);
}
NamespaceManager namespaceClient = new NamespaceManager(baseAddress,credentials);
namespaceClient.CreateQueue(queueDescription);
}
public void CreateQueue_WhenSslErrorOccurs_MessagingExceptionExceptionIsThrown()
{
string queueName = Guid.NewGuid().ToString();
Uri validCertUri = ServiceBusHelper.GetLocalHttpsEndpoint();
Uri invalidCertUri = new Uri("https://localhost:9355/ServiceBusDefaultNamespace");
TokenProvider tokenProvider = TokenProvider.CreateWindowsTokenProvider(new Uri[] { validCertUri });
NamespaceManager nsManager = new NamespaceManager(invalidCertUri, tokenProvider);
Assert.Throws<MessagingException>(() => nsManager.CreateQueue(queueName));
}
private void TryCreateQueueIfNotExists(NamespaceManager namespaceManager, string queueName)
{
if (!namespaceManager.QueueExists(queueName))
{
var queueDescription = new QueueDescription(queueName)
{
MaxSizeInMegabytes = 5120,
DefaultMessageTimeToLive = TimeSpan.FromDays(7),
RequiresDuplicateDetection = false,
MaxDeliveryCount = 10
};
namespaceManager.CreateQueue(queueDescription);
}
}
public bool CreateQueue(string queueId)
{
// Holds credentials and handles tokens from AZS
TokenProvider tokenProvider = GetTokenProvider();
Uri uri = GetServiceBusUri();
var namespaceManager = new NamespaceManager(uri, tokenProvider);
if (!namespaceManager.QueueExists(queueId))
{
namespaceManager.CreateQueue(queueId);
}
throw new NotImplementedException();
}
private QueueClient PrepareWatchingQueue()
{
var namespaceManagerSetting = new NamespaceManagerSettings()
{
TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(ServiceBusIssuerName, ServiceBusIssuerSecret),
};
var namespaceManager = new NamespaceManager(ServiceBusAddress, namespaceManagerSetting);
if (!namespaceManager.QueueExists(_watchingQueueName))
{
namespaceManager.CreateQueue(_watchingQueueName);
}
var factory = MessagingFactory.Create(ServiceBusAddress, SharedSecretTokenProvider.CreateSharedSecretTokenProvider(ServiceBusIssuerName, ServiceBusIssuerSecret));
var queueClient = factory.CreateQueueClient(_watchingQueueName);
return queueClient;
}
private static void CreateQueuesIfNotExists(NamespaceManager namespaceManager, ServiceBusQueueOptions options)
{
foreach (var queue in options.Queues)
{
var prefixed = options.GetQueueName(queue);
if (!namespaceManager.QueueExists(prefixed))
{
var description = new QueueDescription(prefixed);
if (options.Configure != null)
{
options.Configure(description);
}
namespaceManager.CreateQueue(description);
}
}
}
public async static Task MainSync()
{
ServiceNamespace = ConfigurationManager.AppSettings["ServiceNamespace"];
// Issuer key
sasKeyValue = ConfigurationManager.AppSettings["SASKey"];
// Get test async
string testId = "56b747d9fdfad82a0cfdce65";
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://getcmewebapi.azurewebsites.net/");
Task<string> testTask = client.GetStringAsync("api/v1/Test/" + testId);
// do other stuff while we're waiting for the test ...
// Create management credentials
TokenProvider credentials = TokenProvider.CreateSharedAccessSignatureTokenProvider(sasKeyName, sasKeyValue);
NamespaceManager namespaceClient =
new NamespaceManager(
ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, string.Empty),
credentials);
QueueDescription myQueue;
if (!namespaceClient.QueueExists(QUEUE))
{
myQueue = namespaceClient.CreateQueue(QUEUE);
}
MessagingFactory factory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, string.Empty), credentials);
QueueClient myQueueClient = factory.CreateQueueClient(QUEUE);
// Send message
BrokeredMessage message = new BrokeredMessage();
// we need the test now ...
var testJsonString = await testTask;
Test test = JObject.Parse(testJsonString).ToObject<Test>();
message.Properties.Add("TestId", test.Id);
message.Properties.Add("InputDataId", test.InputDataId);
message.Properties.Add("DateSetId", test.DateSetId);
myQueueClient.Send(message);
}
static void Main(string[] args)
{
GetUserCredentials();
TokenProvider credentials = null;
Uri serviceUri = null;
CreateTokenProviderAndServiceUri(out credentials, out serviceUri);
MessagingFactory factory = null;
try
{
NamespaceManager namespaceClient = new NamespaceManager(serviceUri, credentials);
if (namespaceClient == null)
{
Console.WriteLine("\nUnexpected Error: NamespaceManager is NULL");
return;
}
Console.WriteLine("\nCreating Queue '{0}'...", QueueName);
//Eliminar se a queue já existir
if (namespaceClient.QueueExists(QueueName))
namespaceClient.DeleteQueue(QueueName);
namespaceClient.CreateQueue(QueueName);
QueueClient myQueueClient = CreateQueueClient(serviceUri, credentials, out factory);
List<BrokeredMessage> messageList = new List<BrokeredMessage>();
messageList.Add(CreateIssueMessage("1", "First message "));
messageList.Add(CreateIssueMessage("2", "Second message "));
messageList.Add(CreateIssueMessage("3", "Third message "));
SendListOfMessages(messageList, myQueueClient);
}
catch (Exception e)
{
Console.WriteLine("Unexpected exception {0}", e.ToString());
throw;
}
finally
{
if (factory != null)
factory.Close();
}
}
static void Main(string[] args)
{
try
{
if (args.Count() != 0)
{
if (args[0].ToLower().CompareTo("createqueue") == 0)
{
// No processing to occur other than creating the queue.
namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
namespaceManager.CreateQueue(queueName);
Console.WriteLine("Queue named {0} was created.", queueName);
Environment.Exit(0);
}
if (args[0].ToLower().CompareTo("deletequeue") == 0)
{
// No processing to occur other than deleting the queue.
namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
namespaceManager.DeleteQueue(queueName);
Console.WriteLine("Queue named {0} was deleted.", queueName);
Environment.Exit(0);
}
}
//queueClient = QueueClient.CreateFromConnectionString(connectionString, queueName);
Run(305);
Console.WriteLine("Final solution found!");
//queueClient.Send(new BrokeredMessage("Complete"));
//queueClient.Close();
//Environment.Exit(0);
}
catch (ServerBusyException serverBusyException)
{
Console.WriteLine("ServerBusyException encountered");
Console.WriteLine(serverBusyException.Message);
Console.WriteLine(serverBusyException.StackTrace);
if(streamWriter!=null)
{
streamWriter.WriteLine(serverBusyException.Message);
streamWriter.WriteLine(serverBusyException.StackTrace);
streamWriter.Close();
}
int fileCount = GetFileCountFromDir(@"output/")+10;
Run(fileCount);
//Environment.Exit(-1);
}
catch (ServerErrorException serverErrorException)
{
Console.WriteLine("ServerErrorException encountered");
Console.WriteLine(serverErrorException.Message);
Console.WriteLine(serverErrorException.StackTrace);
if (streamWriter != null)
{
streamWriter.WriteLine(serverErrorException.Message);
streamWriter.WriteLine(serverErrorException.StackTrace);
streamWriter.Close();
}
int fileCount = GetFileCountFromDir(@"output/")+10;
Run(fileCount);
//Environment.Exit(-1);
}
catch (Exception exception)
{
Console.WriteLine("Exception encountered");
Console.WriteLine(exception.Message);
Console.WriteLine(exception.StackTrace);
if (streamWriter != null)
{
streamWriter.WriteLine(exception.Message);
streamWriter.WriteLine(exception.StackTrace);
streamWriter.Close();
}
int fileCount = GetFileCountFromDir(@"output/")+10;
Run(fileCount);
//Environment.Exit(-1);
}
}
/// <summary>
/// Setup and connect to Service Bus.
/// </summary>
/// <param name="namespaceManager"></param>
/// <param name="messagingFactory"></param>
/// <param name="durableMessageSender"></param>
private static void ServiceBusConnection(out NamespaceManager namespaceManager, out MessagingFactory messagingFactory, out DurableMessageSender durableMessageSender)
{
//Read user credentials.
//Console.Write("Service Namespace: ");
//string serviceNamespace = Console.ReadLine();
//Console.Write("Issuer Name: ");
//string issuerName = Console.ReadLine();
//Console.Write("Issuer Key: ");
//string issuerKey = Console.ReadLine();
//Console.WriteLine();
string serviceNamespace = "scoring";
string issuerName = "owner";
string issuerKey = "r3JxwjeQwuWwwLasXSQR7tDGx2FCiQLijr9ZBzPCti4=";
Console.WriteLine("Service Namespace: " + serviceNamespace);
Console.WriteLine("Issuer Name: " + issuerName);
Console.WriteLine("Issuer Key: " + issuerKey);
// Create token provider.
Uri namespaceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Empty);
Console.WriteLine("Namespace URI: " + namespaceUri.ToString());
TokenProvider tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerKey);
// Create namespace manager and create Service Bus queue if it does not exist already.
namespaceManager = new NamespaceManager(namespaceUri, tokenProvider);
QueueDescription queueDescription = new QueueDescription(ServiceBusQueueOrTopicName);
queueDescription.RequiresDuplicateDetection = true;
if (!namespaceManager.QueueExists(ServiceBusQueueOrTopicName))
{
namespaceManager.CreateQueue(queueDescription);
Console.WriteLine("Created Service Bus queue \"{0}\".", ServiceBusQueueOrTopicName);
}
// Create a MessagingFactory.
messagingFactory = MessagingFactory.Create(namespaceUri, tokenProvider);
// Create a durable sender.
durableMessageSender = new DurableMessageSender(messagingFactory, ServiceBusQueueOrTopicName);
}
void CreateQueue(NamespaceManager namespaceManager, Uri serviceUri, string queueName)
{
if (namespaceManager == null)
throw new TransportException(serviceUri, "The namespace manager is not available");
var description = new QueueDescription(queueName)
{
DefaultMessageTimeToLive = TimeSpan.FromDays(365),
EnableBatchedOperations = true,
LockDuration = TimeSpan.FromMinutes(5),
MaxDeliveryCount = 5,
EnableDeadLetteringOnMessageExpiration = true,
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(10),
};
try
{
var queueDescription = namespaceManager.CreateQueue(description);
}
catch (MessagingEntityAlreadyExistsException)
{
}
}
static void Main(string[] args)
{
try
{
//String serviceBusNamespace = "azuretest-ns";
//String keyname = "RootManageSharedAccessKey";
//String key = "3HzV1a5bcs/OOj0YS+Iec7XPA9ys2s9oqrUrg8pcILA=";
//String connectionString = @"Endpoint=sb://" +
// serviceBusNamespace +
// @".servicebus.chinacloudapi.cn/;SharedAccessKeyName=" +
// keyname + @";SharedSecretValue=" + key;
String connectionString = @"Endpoint=sb://azuretest-ns.servicebus.chinacloudapi.cn/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=3HzV1a5bcs/OOj0YS+Iec7XPA9ys2s9oqrUrg8pcILA=";
int numCities = 10; // Use as the default, if no value is specified
// at the command line.
if (args.Count() != 0)
{
if (args[0].ToLower().CompareTo("createqueue") == 0)
{
// No processing to occur other than creating the queue.
namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
namespaceManager.CreateQueue(queueName);
Console.WriteLine("Queue named {0} was created.", queueName);
Environment.Exit(0);
}
if (args[0].ToLower().CompareTo("deletequeue") == 0)
{
// No processing to occur other than deleting the queue.
namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
namespaceManager.DeleteQueue("TSPQueue");
Console.WriteLine("Queue named {0} was deleted.", queueName);
Environment.Exit(0);
}
// Neither creating or deleting a queue.
// Assume the value passed in is the number of cities to solve.
numCities = Convert.ToInt32(args[0]);
}
Console.WriteLine("Running for {0} cities.", numCities);
queueClient = QueueClient.CreateFromConnectionString(connectionString, "TSPQueue");
List<int> startCities = new List<int>();
List<int> restCities = new List<int>();
startCities.Add(0);
for (int i = 1; i < numCities; i++)
{
restCities.Add(i);
}
distances = new double[numCities, numCities];
cityNames = new String[numCities];
BuildDistances(@"c:\tsp\cities.txt", numCities);
minDistance = -1;
bestOrder = new int[numCities];
permutation(startCities, 0, restCities);
Console.WriteLine("Final solution found!");
queueClient.Send(new BrokeredMessage("Complete"));
queueClient.Close();
Environment.Exit(0);
}
catch (ServerBusyException serverBusyException)
{
Console.WriteLine("ServerBusyException encountered");
Console.WriteLine(serverBusyException.Message);
Console.WriteLine(serverBusyException.StackTrace);
Environment.Exit(-1);
}
catch (ServerErrorException serverErrorException)
{
Console.WriteLine("ServerErrorException encountered");
Console.WriteLine(serverErrorException.Message);
Console.WriteLine(serverErrorException.StackTrace);
Environment.Exit(-1);
}
catch (Exception exception)
{
Console.WriteLine("Exception encountered");
Console.WriteLine(exception.Message);
Console.WriteLine(exception.StackTrace);
Environment.Exit(-1);
}
}
private QueueClient GetOrCreateQueue(Uri namespaceUri, TokenProvider tokenProvider)
{
NamespaceManager namespaceClient = new NamespaceManager(namespaceUri, tokenProvider);
// Create queue if not already exist.
if (!namespaceClient.QueueExists(MyQueuePath))
{
namespaceClient.CreateQueue(this.queueDescription);
Console.WriteLine("Queue created.");
}
else
{
Console.WriteLine("Queue already exists.");
}
MessagingFactory factory = MessagingFactory.Create(namespaceUri, tokenProvider);
Console.WriteLine("Creating queue client...");
return factory.CreateQueueClient(MyQueuePath, ReceiveMode.PeekLock);
}
private QueueClient CreateQueueIfNecessary(NamespaceManager namespaceManager, string queueName)
{
//Trace.TraceWarning("Does queue exist: " + queueName);
if (!namespaceManager.QueueExists(queueName))
{
Trace.TraceWarning("CreateQueue: " + _connectionString + " " + queueName);
namespaceManager.CreateQueue(queueName);
}
Trace.TraceWarning("Get QueueClient from ConnectionString: " + _connectionString + " " + queueName);
var qc = QueueClient.CreateFromConnectionString(_connectionString, queueName);
if (qc == null)
{
Trace.TraceError("CreateQueue() failed - queueClient is null");
}
return qc;
//return QueueClient.CreateFromConnectionString(_connectionString, queueName);
}
private void WriteQueueMessage(NamespaceManager namespaceManager, string connectionString, string queueName, string message)
{
if (!namespaceManager.QueueExists(queueName))
{
namespaceManager.CreateQueue(queueName);
}
QueueClient queueClient = QueueClient.CreateFromConnectionString(connectionString, queueName);
using (Stream stream = new MemoryStream())
using (TextWriter writer = new StreamWriter(stream))
{
writer.Write(message);
writer.Flush();
stream.Position = 0;
queueClient.Send(new BrokeredMessage(stream) { ContentType = "text/plain" });
}
queueClient.Close();
}
private QueueClient CreateQueueClientIfNotExist(string p_healthMonitorCommandQueueName, bool p_requiresSession, string p_serviceBusUri, TokenProvider p_tokenProvider, NamespaceManager p_namespaceManager)
{
if (!p_namespaceManager.QueueExists(p_healthMonitorCommandQueueName))
{
QueueDescription qDesc = new QueueDescription(p_healthMonitorCommandQueueName);
qDesc.MaxSizeInMegabytes = 5120;
qDesc.DefaultMessageTimeToLive = TimeSpan.FromDays(14); // on Free tier pricing, max 14 days are allowed
qDesc.EnableDeadLetteringOnMessageExpiration = false;
qDesc.LockDuration = TimeSpan.FromMinutes(5); // default is 30seconds, I have changed it to 5minutes, which is the maximum
qDesc.RequiresDuplicateDetection = false;
// 'RequiresSession' cannot be set when creating a Queue IF the namespace 'sqhealthmonitorservicebusqueue-ns' is using free 'Basic' tier.
qDesc.RequiresSession = p_requiresSession; // if there is only one consumer of the command queue, no sessionID is required, for the commandResult there are more consumers
qDesc.EnablePartitioning = true;
// until this line is the properties that can be set in Azure portal
qDesc.EnableBatchedOperations = false; // for low latency, quick response, don't wait miliseconds to batch messages, but send them instantly
var qDescCreated = p_namespaceManager.CreateQueue(qDesc);
}
MessagingFactorySettings mfs = new MessagingFactorySettings();
mfs.TokenProvider = p_tokenProvider;
//mfs.TransportType = TransportType.Amqp; // 400msec latency
mfs.TransportType = Microsoft.ServiceBus.Messaging.TransportType.NetMessaging; // 50msec latency
mfs.NetMessagingTransportSettings.BatchFlushInterval = TimeSpan.Zero; // instead of 20msec, // latency is 37msec was the minimum I measured (instead of 43msec)
MessagingFactory factory = MessagingFactory.Create(p_serviceBusUri, mfs);
var queueClient = factory.CreateQueueClient(p_healthMonitorCommandQueueName, ReceiveMode.PeekLock);
queueClient.PrefetchCount = 0; // it is the default too, and it was 0 in the fast and in the slow cases too
return queueClient;
}
