public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 100;
//Initialize Indexer
storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("CrawlerStorage"));
//Initialize URL Queue
urlQueueClient = storageAccount.CreateCloudQueueClient();
urlQueue = urlQueueClient.GetQueueReference("urlqueue");
if (urlQueue.CreateIfNotExist())
{
//Add first URL to the queue
CloudQueueMessage firstURL = new CloudQueueMessage(startURL);
urlQueue.AddMessage(firstURL);
}
//Initialize Index Queue
indexQueueClient = storageAccount.CreateCloudQueueClient();
indexQueue = indexQueueClient.GetQueueReference("indexqueue");
indexQueue.CreateIfNotExist();
//Initialize Database Blob
databaseClient = storageAccount.CreateCloudBlobClient();
databaseContainer = databaseClient.GetContainerReference("wordfrequencies");
databaseContainer.CreateIfNotExist();
var permission = databaseContainer.GetPermissions();
permission.PublicAccess = BlobContainerPublicAccessType.Container;
databaseContainer.SetPermissions(permission);
return base.OnStart();
}
public override bool OnStart()
{
//EF stuff -- do not initialize db
Database.SetInitializer<SqlStorageContext>(null);
// Set the maximum number of concurrent connections -- do we need this??
//ServicePointManager.DefaultConnectionLimit = 12;
// Create the queue if it does not exist already
var connectionString = CloudConfigurationManager.GetSetting("CloudStore.ConnectionString");
var account = CloudStorageAccount.Parse(connectionString);
var client = account.CreateCloudQueueClient();
_queue = client.GetQueueReference(QueueName);
_queue.CreateIfNotExist();
// set diagnostics
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
// Windows Azure logs
config.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0); //60 sec is min
config.Logs.ScheduledTransferLogLevelFilter = LogLevel.Undefined; //Undefined == everything
var diagAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString"));
var roleInstanceDiagnosticManager =
diagAccount.CreateRoleInstanceDiagnosticManager(RoleEnvironment.DeploymentId,
RoleEnvironment.CurrentRoleInstance.Role.Name,
RoleEnvironment.CurrentRoleInstance.Id);
roleInstanceDiagnosticManager.SetCurrentConfiguration(config);
return base.OnStart();
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
DiagnosticMonitor.Start("DiagnosticsConnectionString");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
// read storage account configuration settings
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter)
=> configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)));
var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
// initialize blob storage
CloudBlobClient blobStorage = storageAccount.CreateCloudBlobClient();
container = blobStorage.GetContainerReference("converteddata");
// initialize queue storage
CloudQueueClient queueStorage = storageAccount.CreateCloudQueueClient();
queue = queueStorage.GetQueueReference("workercommands");
Trace.TraceInformation("Creating container and queue...");
bool storageInitialized = false;
while (!storageInitialized)
{
try
{
// create the blob container and allow public access
container.CreateIfNotExist();
var permissions = container.GetPermissions();
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
container.SetPermissions(permissions);
// create the message queue
queue.CreateIfNotExist();
storageInitialized = true;
}
catch (StorageClientException e)
{
if (e.ErrorCode == StorageErrorCode.TransportError)
{
Trace.TraceError("Storage services initialization failure. "
+ "Check your storage account configuration settings. If running locally, "
+ "ensure that the Development Storage service is running. Message: '{0}'", e.Message);
Thread.Sleep(5000);
}
else
{
throw;
}
}
}
return base.OnStart();
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
#if DEBUG
account = CloudStorageAccount.DevelopmentStorageAccount;
#else
account = new CloudStorageAccount(accountAndKey, true);
#endif
tableContext = new TableServiceContext(account.TableEndpoint.ToString(), account.Credentials);
//client = new CloudQueueClient(account.BlobEndpoint.ToString(), account.Credentials);
qclient = account.CreateCloudQueueClient();
q = qclient.GetQueueReference("icd9mapplotrequests");
rows = new List<ICD9MapPlotResultEntry>();
bclient = account.CreateCloudBlobClient();
container = bclient.GetContainerReference("results");
container.CreateIfNotExist();
client = account.CreateCloudTableClient();
client.CreateTableIfNotExist("ICD9MapPlotResult");
client.CreateTableIfNotExist("DoctorDetails");
client.CreateTableIfNotExist("PatientDetails");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
return base.OnStart();
}
public QueueFrases()
{
queueClient = storageAccount.CreateCloudQueueClient();
this.frasesParaProcessasQueue = this.queueClient.GetQueueReference("frasesparaprocessar");
this.frasesParaProcessasQueue.CreateIfNotExist();
}
public RepositorioDePagamentosParaProcessar()
{
queueClient = storageAccount.CreateCloudQueueClient();
this.vendasParaProcessasQueue = this.queueClient.GetQueueReference("vendasparaprocessar");
this.vendasParaProcessasQueue.CreateIfNotExist();
}
public AnObjectEventConsumer()
{
var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("Storage"));
var queueClient = storageAccount.CreateCloudQueueClient();
_queue = queueClient.GetQueueReference("anobjectqueue");
_queue.CreateIfNotExist();
}
public StatelessAzureQueueWriter(IEnvelopeStreamer streamer, CloudBlobContainer container, CloudQueue queue, string name)
{
_streamer = streamer;
_cloudBlob = container;
_queue = queue;
Name = name;
}
public AddMessagesExample( String queueName)
{
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["DataConnectionString"]);
CloudQueueClient cloudQueueClient = cloudStorageAccount.CreateCloudQueueClient();
cloudQueue = cloudQueueClient.GetQueueReference(queueName);
cloudQueue.CreateIfNotExist();
}
public LargeDataExample(String queueName)
{
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["DataConnectionString"]);
CloudQueueClient cloudQueueClient = cloudStorageAccount.CreateCloudQueueClient();
cloudQueue = cloudQueueClient.GetQueueReference(queueName);
cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// read storage account configuration settings
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
});
var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
// initialize blob storage
var blobStorage = storageAccount.CreateCloudBlobClient();
blobContainer = blobStorage.GetContainerReference("guestbookpics");
// initialize queue storage
var queueStorage = storageAccount.CreateCloudQueueClient();
queue = queueStorage.GetQueueReference("guestbookthumbs");
Trace.TraceInformation("Creating container and queue...");
bool storageInitialized = false;
while (!storageInitialized)
{
try
{
// create the blob container and allow public access
this.blobContainer.CreateIfNotExist();
var permissions = this.blobContainer.GetPermissions();
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
this.blobContainer.SetPermissions(permissions);
// create the message queue(s)
this.queue.CreateIfNotExist();
storageInitialized = true;
}
catch (StorageClientException e)
{
if (e.ErrorCode == StorageErrorCode.TransportError)
{
Trace.TraceError(
"Storage services initialization failure. "
+ "Check your storage account configuration settings. If running locally, "
+ "ensure that the Development Storage service is running. Message: '{0}'",
e.Message);
System.Threading.Thread.Sleep(5000);
}
else
{
throw;
}
}
}
return base.OnStart();
}
public DefaultJobSupplier()
{
Logger.Log.Instance.Info(string.Format("DefaultJobSupplier. Constructor. Create queue '{0}' client", RoleSettings.JobRequestsQueueName));
_queue = AzureClient.Instance.QueueClient.GetQueueReference(RoleSettings.JobRequestsQueueName);
Logger.Log.Instance.Info(string.Format("DefaultJobSupplier. Queue client created: {0}",
_queue == null ? "failed" : "successfully"));
_queue.CreateIfNotExist();
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// Restart the role upon all configuration changes
RoleEnvironment.Changing += RoleEnvironmentChanging;
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
try
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
}
catch (RoleEnvironmentException e)
{
Trace.TraceError(e.Message);
System.Threading.Thread.Sleep(5000);
}
});
CloudStorageAccount storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
// initialize queue storage
CloudQueueClient queueStorage = storageAccount.CreateCloudQueueClient();
requestQueue = queueStorage.GetQueueReference("requests");
responseQueue = queueStorage.GetQueueReference("responses");
bool storageInitialized = false;
while (!storageInitialized)
{
try
{
// create the message queue
requestQueue.CreateIfNotExist();
responseQueue.CreateIfNotExist();
storageInitialized = true;
}
catch (StorageClientException e)
{
if (e.ErrorCode == StorageErrorCode.TransportError)
{
Trace.TraceError("Storage services initialization failure. "
+ "Check your storage account configuration settings. If running locally, "
+ "ensure that the Development Storage service is running. Message: '{0}'", e.Message);
System.Threading.Thread.Sleep(5000);
}
else
{
throw;
}
}
}
return base.OnStart();
}
public SingleDeliveryQueueClient(CloudStorageAccount account, string queueName)
{
var queueClient = account.CreateCloudQueueClient();
queue = queueClient.GetQueueReference(queueName);
queue.CreateIfNotExist();
tableClient = account.CreateCloudTableClient();
tableClient.CreateTableIfNotExist(TableName);
}
public QueueClient()
{
var account = CloudStorageAccount.DevelopmentStorageAccount;
var queueClient = account.CreateCloudQueueClient();
this.queue = queueClient.GetQueueReference("messages");
this.queue.CreateIfNotExist();
}
public AzureChannel(CloudQueue queue)
{
if (queue == null)
{
throw new ArgumentNullException("queue");
}
this.queue = queue;
}
public QueueClient()
{
var account = CloudStorageAccount.FromConfigurationSetting("QueueSettings");
var queueClient = account.CreateCloudQueueClient();
this.queue = queueClient.GetQueueReference("messages");
this.queue.CreateIfNotExist();
}
public ProcessingQueue()
{
_formatter = new BinaryFormatter();
storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString"));
queueClient = storageAccount.CreateCloudQueueClient();
queue = queueClient.GetQueueReference(TableName);
queue.CreateIfNotExist();
}
public ProcessingQueue()
{
_formatter = new BinaryFormatter();
storageAccount = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["StorageConnectionString"]);
queueClient = storageAccount.CreateCloudQueueClient();
queue = queueClient.GetQueueReference(TableName);
queue.CreateIfNotExist();
}
public override ChannelState Close()
{
lock (Locker)
{
_queue = null;
State = ChannelState.Closed;
}
return State;
}
public AzureMessageQueueTransactionSimulator(CloudQueue inputQueue)
{
_inputQueue = inputQueue;
if (Transaction.Current != null)
{
_enlistedInAmbientTx = true;
Transaction.Current.EnlistVolatile(this, EnlistmentOptions.None);
}
}
public AzureQueueTraceListener(string applicationName, string queueConnectionString, string queueName = "tracelogs")
{
if (string.IsNullOrEmpty(applicationName))
throw new ArgumentNullException("applicationName",
"You must define an ApplicationName to log trace messages");
ApplicationName = applicationName;
var storageAccount = CloudStorageAccount.Parse(queueConnectionString);
var queueClient = storageAccount.CreateCloudQueueClient();
_queue = queueClient.GetQueueReference(queueName);
_queue.CreateIfNotExist();
}
public StatelessAzureQueueReader(
string name,
CloudQueue primaryQueue,
CloudBlobDirectory container,
Lazy<CloudQueue> poisonQueue,
TimeSpan visibilityTimeout)
{
_cloudBlob = container;
_queue = primaryQueue;
_posionQueue = poisonQueue;
_queueName = name;
_visibilityTimeout = visibilityTimeout;
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
_membershipsPumpQueue = StorageService.GetCloudQueue(StorageConstants.MembershipsPumpQueue);
_testMembershipsPumpQueue = StorageService.GetCloudQueue(StorageConstants.TestMembershipPumpQueue);
return base.OnStart();
}
public MsdnQueueSource()
{
queueClient = storageAccount.CreateCloudQueueClient();
this.namespacesQueue = this.queueClient.GetQueueReference("namespaces");
this.namespacesQueue.CreateIfNotExist();
this.typesQueue = this.queueClient.GetQueueReference("types");
this.typesQueue.CreateIfNotExist();
this.membersQueue = this.queueClient.GetQueueReference("members");
this.membersQueue.CreateIfNotExist();
}
//----------------------------------------------------------------------
// ToDo.CountMutualFriends
//
// Input : requestQueue - queue to sent messages to worker roles
// responseQueue - queue to receive messages from worker roles
// Return : A dictionary which contains the number of mutual friends for each user
// Purpose : Count the number of mutual friends for each user
// Note : You should implement the case of arriving messages from worker roles via responseQueue.
// The messages have numbers of mutual friends for each user
// in a way you describe in ToDo.CountMutualFriendsInEachWorkerRole.
// You should check whether there is a message of the counts in the responseQueue,
// and aggregate the counts from worker roles.
//
// * Data type of dictionary which will be returned is Dictionary<int, int>.
// Key (first generic type parameter) of this dictionary indicates user ID.
// Value (second generic type parameter) of this dictionary indicates
// the number of mutual friends of the user.
//----------------------------------------------------------------------
public static Dictionary<int, int> CountMutualFriends(CloudQueue requestQueue, CloudQueue responseQueue)
{
Dictionary<int, int> countMutualFriends = new Dictionary<int, int>();
// request each worker role to count mutual friends it found
for (int i = 0; i < ToDo.NumWorkerRoleInstances; i++)
requestQueue.AddMessage(new CloudQueueMessage("COUNT_MUTUAL_FRIENDS_#" + i));
// wait for finishing all of worker roles
int numFinishedRoles = 0;
while (numFinishedRoles < ToDo.NumWorkerRoleInstances)
{
// retrieve a new message from the queue
CloudQueueMessage msg = responseQueue.GetMessage();
if (msg == null)
{
System.Threading.Thread.Sleep(sleepTime);
continue;
}
// remove message from queue
responseQueue.DeleteMessage(msg);
string msgStr = msg.AsString;
if (msgStr.StartsWith("COMPLETE_COUNTING_MUTUAL_FRIENDS"))
{
numFinishedRoles++;
}
else
{
// YOU MUST IMPLEMENT ADDITIONAL CODE HERE
//
// * To receive the number of friends of users from worker roles, using response queue,
//
// check whether there is a message for the counts in the response queue,
// and aggregate the counts from every worker role.
String[] split = msgStr.Split(new Char[] { ':' });
int key = Convert.ToInt32(split[0]);
int value = Convert.ToInt32(split[1]);
if (countMutualFriends.ContainsKey(key))
countMutualFriends[key] += value;
else
countMutualFriends.Add(key, value);
}
}
return countMutualFriends;
}
SearchEngine()
{
// Instantiate the AzureDirectory storage object for use by Lucene
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(CloudSettingsResolver.GetConfigSetting(configName));
});
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.FromConfigurationSetting("BlobStorageEndpoint");
_Directory = new AzureDirectory(cloudStorageAccount, "LuceneStorage", new RAMDirectory());
// Create search index queue
CloudQueueClient client = cloudStorageAccount.CreateCloudQueueClient();
_CloudQueue = client.GetQueueReference("searchindexqueue");
_CloudQueue.CreateIfNotExist();
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
var storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("QueueInterRole"));
var queueClient = storageAccount.CreateCloudQueueClient();
_queue = queueClient.GetQueueReference("myqueue");
_queue.CreateIfNotExist();
return base.OnStart();
}
// Initialize
public void Initialize(string queueName)
{
// create the queue
try
{
// ?? why is this API behavior different from Tables?
physicalQueue = cloudAccount.QueueClient.GetQueueReference(queueName);
physicalQueue.CreateIfNotExist();
}
catch (StorageClientException ex)
{
// TODO: not sure what to do with the exception
throw ex;
}
}
static Action<IAsyncResult> EndDelete(CloudQueue c)
{
return result =>
{
try
{
c.EndDelete(result);
}
catch (StorageClientException ex)
{
if (ex.ErrorCode == StorageErrorCode.ResourceNotFound)
return;
throw;
}
};
}
