public void GetUriThrows()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var surveyAnswerStorage = new EntitiesBlobContainer <SurveyAnswer>(account, SurveyAnswersContainer);
Assert.IsTrue(surveyAnswerStorage.GetUri("id").ToString().EndsWith("/surveyanswersfortest/id"));
}
public static void Initialize()
{
CloudStorageAccount account = CloudConfiguration.GetStorageAccount(AzureConnectionStrings.DataConnection);
// Tables
var cloudTableClient = new CloudTableClient(account.TableEndpoint.ToString(), account.Credentials);
cloudTableClient.CreateTableIfNotExist <ExpenseExpenseItemEntity>(AzureStorageNames.ExpenseTable);
cloudTableClient.CreateTableIfNotExist <ExpenseExportEntity>(AzureStorageNames.ExpenseExportTable);
// Blobs
CloudBlobClient client = account.CreateCloudBlobClient();
client.RetryPolicy = RetryPolicies.Retry(3, TimeSpan.FromSeconds(5));
var container = client.GetContainerReference(AzureStorageNames.ReceiptContainerName);
container.CreateIfNotExist();
container = client.GetContainerReference(AzureStorageNames.ExpenseExportContainerName);
container.CreateIfNotExist();
// Queues
CloudQueueClient queueClient = account.CreateCloudQueueClient();
queueClient.RetryPolicy = RetryPolicies.Retry(3, TimeSpan.FromSeconds(5));
CloudQueue queueReference = queueClient.GetQueueReference(AzureStorageNames.ApprovedExpenseMessage);
queueReference.CreateIfNotExist();
queueReference = queueClient.GetQueueReference(AzureStorageNames.PoisonApprovedExpenseMessage);
queueReference.CreateIfNotExist();
queueReference = queueClient.GetQueueReference(AzureStorageNames.NewReceiptMessage);
queueReference.CreateIfNotExist();
queueReference = queueClient.GetQueueReference(AzureStorageNames.PoisonNewReceiptMessage);
queueReference.CreateIfNotExist();
}
private bool HasModelExtensionAssembly(string tenant, out string assemblyFile, out string @namespace)
{
var result = false;
assemblyFile = null;
@namespace = null;
if (SubscriptionKind.Premium.Equals(this.Tenant.SubscriptionKind) &&
!string.IsNullOrWhiteSpace(this.Tenant.ModelExtensionAssembly) &&
!string.IsNullOrWhiteSpace(this.Tenant.ModelExtensionNamespace))
{
var extensionsPath = CloudConfiguration.GetConfigurationSetting(ExtensionsPath);
if (!Path.IsPathRooted(extensionsPath))
{
extensionsPath = Path.Combine(HostingEnvironment.ApplicationPhysicalPath, extensionsPath);
}
assemblyFile = Path.Combine(extensionsPath, string.Format("{0}.dll", this.Tenant.ModelExtensionAssembly));
@namespace = this.Tenant.ModelExtensionNamespace;
result = true;
}
return(result);
}
public static void Initialize(TestContext context)
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var newSurveyAnswerQueue = new AzureQueue <MessageForTests>(account);
newSurveyAnswerQueue.EnsureExist();
}
public void UpdateMessageThrowIfMessageRefIsNull()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var queue = new AzureQueue <MessageForTests>(account, "messagefortests", TimeSpan.FromSeconds(1));
queue.UpdateMessage(new MessageForTests());
}
public AzureUpdater(AzureDiscoveryInfo discoveryInfo)
{
_info = discoveryInfo;
_provisioning = new AzureProvisioning(
CloudConfiguration.SubscriptionId,
CloudConfiguration.GetManagementCertificate());
}
public void ReleaseResourceAllowsGettingNewLock()
{
var azureBlobContainer = new TestAzureBlobContainer(
CloudConfiguration.GetStorageAccount("DataConnectionString"),
AzureBlobTestContainer);
var objId = Guid.NewGuid().ToString();
azureBlobContainer.Save(objId, "testText");
var lockContext = new PessimisticConcurrencyContext()
{
ObjectId = objId
};
Assert.IsTrue(azureBlobContainer.AcquireLock(lockContext));
Assert.IsNotNull(lockContext.LockId);
var firstLockId = lockContext.LockId;
azureBlobContainer.ReleaseLock(lockContext);
Assert.IsTrue(azureBlobContainer.AcquireLock(lockContext));
Assert.IsNotNull(lockContext.LockId);
Assert.AreNotEqual(firstLockId, lockContext.LockId);
}
public async Task SaveManyAndDeleteMany()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var azureTable = new AzureTable <TestRow>(account, TableName);
var row1 = new TestRow {
PartitionKey = "partition_key_SaveManyAndDeleteMany", RowKey = "row_key_1_SaveManyAndDeleteMany", ETag = "*"
};
var row2 = new TestRow {
PartitionKey = "partition_key_SaveManyAndDeleteMany", RowKey = "row_key_2_SaveManyAndDeleteMany", ETag = "*"
};
await azureTable.DeleteAsync(new[] { row1, row2 });
var rowsToDelete = await azureTable.GetByPartitionKeyAsync("partition_key_SaveManyAndDeleteMany");
Assert.AreEqual(0, rowsToDelete.Count());
row1.ETag = string.Empty;
row2.ETag = string.Empty;
await azureTable.AddAsync(new[] { row1, row2 });
var insertedRows = await azureTable.GetByPartitionKeyAsync("partition_key_SaveManyAndDeleteMany");
Assert.AreEqual(2, insertedRows.Count());
await azureTable.DeleteAsync(new[] { row1, row2 });
var actualRows = await azureTable.GetByPartitionKeyAsync("partition_key_SaveManyAndDeleteMany");
Assert.AreEqual(0, actualRows.Count());
}
public async Task AddOrUpdateAddsWhenNotExists()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var azureTable = new AzureTable <TestRow>(account, TableName);
var row = new TestRow
{
PartitionKey = "partition_key_AddOrUpdateAddsWhenNotExists",
RowKey = "row_key_AddOrUpdateAddsWhenNotExists",
Content = "content"
};
await azureTable.DeleteAsync(row);
TestRow deletedRow = (await azureTable.GetByRowKeyAsync(row.RowKey)).SingleOrDefault();
Assert.IsNull(deletedRow);
await azureTable.AddOrUpdateAsync(row);
TestRow savedRow = await azureTable.GetByPartitionRowKeyAsync("partition_key_AddOrUpdateAddsWhenNotExists", row.RowKey);
Assert.IsNotNull(savedRow);
Assert.AreEqual("content", savedRow.Content);
}
public async Task GetByPartitionRowKey_Returns_SpecificEntity()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var azureTable = new AzureTable <TestRow>(account, TableName);
var row1 = new TestRow {
PartitionKey = "GetByPartitionRowKey_Returns_SpecificEntity", RowKey = "row_key_1_GetByPartitionRowKey_Returns_SpecificEntity", Content = "content 1", ETag = "*"
};
var row2 = new TestRow {
PartitionKey = "GetByPartitionRowKey_Returns_SpecificEntity", RowKey = "row_key_2_GetByPartitionRowKey_Returns_SpecificEntity", Content = "content 2", ETag = "*"
};
var row3 = new TestRow {
PartitionKey = "GetByPartitionRowKey_Returns_SpecificEntity", RowKey = "row_key_3_GetByPartitionRowKey_Returns_SpecificEntity", Content = "content 3", ETag = "*"
};
await azureTable.DeleteAsync(new[] { row1, row2, row3 });
var rowsToDelete = await azureTable.GetByPartitionKeyAsync("GetByPartitionRowKey_Returns_SpecificEntity");
Assert.AreEqual(0, rowsToDelete.Count());
await azureTable.AddAsync(new[] { row1, row2, row3 });
var retrievedRow = await azureTable.GetByPartitionRowKeyAsync("GetByPartitionRowKey_Returns_SpecificEntity", "row_key_2_GetByPartitionRowKey_Returns_SpecificEntity");
Assert.AreEqual(row2.Content, retrievedRow.Content);
}
public async Task GetByPartitionKey_Returns_SpecificEntities()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var azureTable = new AzureTable <TestRow>(account, TableName);
var row1 = new TestRow {
PartitionKey = "partition_key_1_GetByPartitionKey_Returns_SpecificEntities", RowKey = "row_key_1_GetByPartitionKey_Returns_SpecificEntities", Content = "content 1", ETag = "*"
};
var row2 = new TestRow {
PartitionKey = "partition_key_2_GetByPartitionKey_Returns_SpecificEntities", RowKey = "row_key_2_GetByPartitionKey_Returns_SpecificEntities", Content = "content 2", ETag = "*"
};
var row3 = new TestRow {
PartitionKey = "partition_key_2_GetByPartitionKey_Returns_SpecificEntities", RowKey = "row_key_3_GetByPartitionKey_Returns_SpecificEntities", Content = "content 3", ETag = "*"
};
await azureTable.DeleteAsync(row1);
await azureTable.DeleteAsync(row2);
await azureTable.DeleteAsync(row3);
await azureTable.AddAsync(row1);
await azureTable.AddAsync(row2);
await azureTable.AddAsync(row3);
var retrievedRows = await azureTable.GetByPartitionKeyAsync("partition_key_2_GetByPartitionKey_Returns_SpecificEntities");
Assert.AreEqual(2, retrievedRows.Count());
Assert.AreEqual(row2.Content, retrievedRows.ToList()[0].Content);
}
public async Task AddOrUpdateMany()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var azureTable = new AzureTable <TestRow>(account, TableName);
var row1 = new TestRow {
PartitionKey = "partition_key_AddOrUpdateMany", RowKey = "row_key_1_AddOrUpdateMany", Content = "content 1", ETag = "*"
};
var row2 = new TestRow {
PartitionKey = "partition_key_AddOrUpdateMany", RowKey = "row_key_2_AddOrUpdateMany", Content = "content 2", ETag = "*"
};
await azureTable.DeleteAsync(new[] { row1, row2 });
var rowsToDelete = await azureTable.GetByPartitionKeyAsync("partition_key_AddOrUpdateMany");
Assert.AreEqual(0, rowsToDelete.Count());
await azureTable.AddAsync(row1);
var actualRows = await azureTable.GetByPartitionKeyAsync("partition_key_AddOrUpdateMany");
Assert.AreEqual(1, actualRows.Count());
row1.Content = "content modified";
await azureTable.AddOrUpdateAsync(new[] { row1, row2 });
var insertedRows = await azureTable.GetByPartitionKeyAsync("partition_key_AddOrUpdateMany");
Assert.AreEqual(2, insertedRows.Count());
TestRow updatedRow = await azureTable.GetByPartitionRowKeyAsync("partition_key_AddOrUpdateMany", row1.RowKey);
Assert.IsNotNull(updatedRow);
Assert.AreEqual("content modified", updatedRow.Content);
}
public RootConfiguration(CloudConfiguration cloud, ModuleAliasesConfiguration moduleAliases, AnalyzersConfiguration analyzers, string?configurationPath)
{
this.Cloud = cloud;
this.ModuleAliases = moduleAliases;
this.Analyzers = analyzers;
this.ConfigurationPath = configurationPath;
}
public void ProcessURL(string URL)
{
try
{
URL = URL.ToLower();
VisitedLinks.Add(URL);
if (URL.EndsWith("txt"))
{
ProcessTxt(URL);
}
else if (URL.EndsWith("xml"))
{
ProcessXML(URL);
}
else
{
ProcessHTML(URL);
}
}
catch (Exception ex)
{
CloudQueueMessage error = new CloudQueueMessage(URL);
CloudConfiguration.GetErrorQueue().AddMessage(error);
}
}
public override void Run()
{
try
{
CloudStorageAccount account = CloudConfiguration.GetStorageAccount(AzureConnectionStrings.DataConnection);
// Receipt Queue
var receiptQueue = new AzureQueue <NewReceiptMessage>(account, AzureStorageNames.NewReceiptMessage);
var poisonReceiptQueue = new AzureQueue <NewReceiptMessage>(account, AzureStorageNames.PoisonNewReceiptMessage);
var receiptQueueCommand = new ReceiptThumbnailQueueCommand();
QueueCommandHandler.For(receiptQueue).Every(TimeSpan.FromSeconds(5)).WithPosionMessageQueue(poisonReceiptQueue).Do(receiptQueueCommand);
// ExpenseExportQueueCommand
var exportQueue = new AzureQueue <ApprovedExpenseMessage>(account, AzureStorageNames.ApprovedExpenseMessage);
var poisonExportQueue = new AzureQueue <ApprovedExpenseMessage>(account, AzureStorageNames.PoisonApprovedExpenseMessage);
var exportQueueCommand = new ExpenseExportQueueCommand();
QueueCommandHandler.For(exportQueue).Every(TimeSpan.FromSeconds(5)).WithPosionMessageQueue(poisonExportQueue).Do(exportQueueCommand);
// Expense Export
CommandHandler.Every(TimeSpan.FromSeconds(60)).Do(new ExpenseExportCommand());
while (true)
{
Thread.Sleep(TimeSpan.FromSeconds(5));
}
}
catch (Exception e)
{
Log.Write(EventKind.Error, e.Message);
throw;
}
}
public SqlDatabaseEventProcessor()
{
//We have to get the config from the container unfortunately since this class
//is being constructed by the event processor host
_cloudConfig = ServiceLocator.Current.GetInstance <CloudConfiguration>();
_datasourceRecordSerializer = ServiceLocator.Current.GetInstance <IDatasourceRecordSerializer>();
}
public static void Cleanup()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var surveyAnswerStorage = new EntitiesBlobContainer <SurveyAnswer>(account, SurveyAnswersContainer);
surveyAnswerStorage.DeleteContainerAsync().Wait();
}
public async Task ShouldSaveAndRetrieveCustomEntities()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var customEntity1 = new CustomEntity()
{
PartitionKey = "ShouldSaveAndRetrieveCustomEntities",
RowKey = "ShouldSaveAndRetrieveCustomEntities_RowKey1",
Id = 6,
Name = "six"
};
var customEntity2 = new CustomEntity()
{
PartitionKey = "ShouldSaveAndRetrieveCustomEntities",
RowKey = "ShouldSaveAndRetrieveCustomEntities_RowKey2",
Id = 7,
Name = "seven"
};
var udfAzureTable = new UDFAzureTable(account, TableName);
await udfAzureTable.SaveAsync(customEntity1);
await udfAzureTable.SaveAsync(customEntity2);
var storedEntities = await udfAzureTable.GetExtensionsByPartitionKeyAsync(typeof(CustomEntity), "ShouldSaveAndRetrieveCustomEntities");
Assert.IsNotNull(storedEntities);
Assert.AreEqual(customEntity1.ToString(), storedEntities.ToList()[0].ToString());
Assert.AreEqual(customEntity2.ToString(), storedEntities.ToList()[1].ToString());
}
public void LockAndWriteResource()
{
var azureBlobContainer = new TestAzureBlobContainer(
CloudConfiguration.GetStorageAccount("DataConnectionString"),
AzureBlobTestContainer);
var objId = Guid.NewGuid().ToString();
azureBlobContainer.Save(objId, "testText");
var context = new PessimisticConcurrencyContext()
{
ObjectId = objId
};
try
{
azureBlobContainer.AcquireLock(context);
azureBlobContainer.Save(context, "testTextUpdated");
}
finally
{
azureBlobContainer.ReleaseLock(context);
}
Assert.AreEqual("testTextUpdated", azureBlobContainer.Get(objId));
}
public static void Initialize(TestContext context)
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var surveyAnswerStorage = new EntitiesBlobContainer <SurveyAnswer>(account, SurveyAnswersContainer);
surveyAnswerStorage.EnsureExistsAsync().Wait();
}
public void SaveManyAndDeleteMany()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var azureTable = new AzureTable <TestRow>(account, TableName);
var row1 = new TestRow {
PartitionKey = "partition_key_SaveManyAndDeleteMany", RowKey = "row_key_1_SaveManyAndDeleteMany"
};
var row2 = new TestRow {
PartitionKey = "partition_key_SaveManyAndDeleteMany", RowKey = "row_key_2_SaveManyAndDeleteMany"
};
azureTable.Delete(new[] { row1, row2 });
var rowsToDelete = (from o in azureTable.Query
where o.PartitionKey == "partition_key_SaveManyAndDeleteMany"
select o).ToList();
Assert.AreEqual(0, rowsToDelete.Count);
azureTable.Add(new[] { row1, row2 });
var insertedRows = (from o in azureTable.Query
where o.PartitionKey == "partition_key_SaveManyAndDeleteMany"
select o).ToList();
Assert.AreEqual(2, insertedRows.Count);
azureTable.Delete(new[] { row1, row2 });
var actualRows = (from o in azureTable.Query
where o.PartitionKey == "partition_key_SaveManyAndDeleteMany"
select o).ToList();
Assert.AreEqual(0, actualRows.Count);
}
public void CreateNewInstance()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var azureTable = new AzureTable <TestRow>(account);
Assert.IsInstanceOfType(azureTable, typeof(AzureTable <TestRow>));
}
public void DeleteAndAddAndGet()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var azureTable = new AzureTable <TestRow>(account, TableName);
var row = new TestRow
{
PartitionKey = "partition_key_DeleteAndAddAndGet",
RowKey = "row_key_DeleteAndAddAndGet",
Content = "content"
};
azureTable.Delete(row);
TestRow deletedRow = (from o in azureTable.Query
where o.RowKey == row.RowKey
select o).SingleOrDefault();
Assert.IsNull(deletedRow);
azureTable.Add(row);
TestRow savedRow = (from o in azureTable.Query
where o.RowKey == row.RowKey &&
o.PartitionKey == "partition_key_DeleteAndAddAndGet" &&
o.Content == "content"
select o).SingleOrDefault();
Assert.IsNotNull(savedRow);
azureTable.Delete(row);
TestRow actualRow = (from o in azureTable.Query
where o.RowKey == row.RowKey
select o).SingleOrDefault();
Assert.IsNull(actualRow);
}
public void AddOrUpdateAddsWhenNotExists()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var azureTable = new AzureTable <TestRow>(account, TableName);
azureTable.RetryPolicyFactory = new DefaultRetryPolicyFactory();
var row = new TestRow
{
PartitionKey = "partition_key_AddOrUpdateAddsWhenNotExists",
RowKey = "row_key_AddOrUpdateAddsWhenNotExists",
Content = "content"
};
azureTable.Delete(row);
TestRow deletedRow = (from o in azureTable.Query
where o.RowKey == row.RowKey
select o).SingleOrDefault();
Assert.IsNull(deletedRow);
azureTable.AddOrUpdate(row);
TestRow savedRow = (from o in azureTable.Query
where o.RowKey == row.RowKey &&
o.PartitionKey == "partition_key_AddOrUpdateAddsWhenNotExists" &&
o.Content == "content"
select o).SingleOrDefault();
Assert.IsNotNull(savedRow);
}
public static void Initialize(TestContext context)
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var azureTable = new AzureTable <TestRow>(account, TableName);
azureTable.EnsureExist();
}
public static void Initialize(TestContext context)
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var logoStorage = new FilesBlobContainer(account, LogoStoreContainer, "xxx");
logoStorage.EnsureExist();
}
public static void Cleanup()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var logoStorage = new FilesBlobContainer(account, LogoStoreContainer, "xxx");
logoStorage.DeleteContainer();
}
public string GetStatus()
{
AdminStatusTable = CloudConfiguration.GetAdminStatusTable();
var status = AdminStatusTable.ExecuteQuery(new TableQuery <AdminStatus>()).ToList();
return(new JavaScriptSerializer().Serialize(status));
}
public string GetSearchResults(string query)
{
SiteDataTable = CloudConfiguration.GetSiteDataTable();
query = query.Trim().ToLower();
if (cache.ContainsKey(query))
{
return(new JavaScriptSerializer().Serialize(cache[query]));
}
else
{
var keywords = query.Split(null)
.Select(x => Base64.Base64Encode(x));
var results = new List <URLEntity>();
foreach (string keyword in keywords)
{
TableQuery <URLEntity> rangeQuery = new TableQuery <URLEntity>()
.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, keyword));
var data = SiteDataTable.ExecuteQuery(rangeQuery);
results.AddRange(data);
}
var siteMatches = results.GroupBy(x => x.URL)
.Select(group => new Tuple <string, int, string>(group.Key, group.Count(), group.First().Title))
.OrderByDescending(tuple => tuple.Item2);
var links = siteMatches.Select(x => x.Item1 + "$" + x.Item3).ToList <string>();
cache.Add(query, links);
return(new JavaScriptSerializer().Serialize(links));
}
}
public ATSRepository(string containerName)
{
this.account = CloudConfiguration.GetStorageAccount("StorageConnectionString");
this.cloudBlobClient = account.CreateCloudBlobClient();
this.cloudBlobContainer = cloudBlobClient.GetContainerReference(containerName);
this.cloudBlobContainer.CreateIfNotExists();
}
public DeviceDataBlobWriter(CloudConfiguration configuration, IDatasourceRecordSerializer serializer)
{
_config = configuration;
//_repository = repository;
_serializer = serializer;
_connectionString = _config.DataStorageConfiguration.GetConnectionString();
// Retrieve storage account from connection string.
_storageAccount = CloudStorageAccount.Parse(_connectionString);
// Create the blob client.
CloudBlobClient blobClient = _storageAccount.CreateCloudBlobClient();
}
public ReactiveTest(CloudConfiguration configuration, IDatasourceRecordSerializer serializer)
{
_config = configuration;
_serializer = serializer;
}
/// <summary>
/// Initializes static members of the <see cref="CloudContext" /> class.
/// </summary>
static CloudContext()
{
Clients = new CloudClients();
Configuration = new CloudConfiguration();
}
