public async Task AzureStorageProvider_Save()
{
//ClearAzureTable( PartitionKey ).Wait();
XDocument schema = AzureTableStorageProvider.GetDefaultSchema();
TelemetryClient client = new TelemetryClient();
ErrorReport report;
try {
throw new GenericException(ErrorCode.GENERIC_CRITICAL_ERROR, "Test Exception Message");
} catch (Exception e) {
report = new ErrorReport(e);
client.AddActiveReport(report);
}
await client.UploadActiveReportsAsync(AzureStorageEmulator);
TableQuery <DynamicTableEntity> retrieve = new TableQuery <DynamicTableEntity>().Where(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, PartitionKey)
);
//var entities = AzureStorageEmulator.StorageTable.ExecuteQuerySegmentedAsync( retrieve, null );
//return StorageTable.ExecuteAsync( BuildInsertOperation( report ) ).AsTask();
//Assert.AreEqual( report.ActivityTime.ToString( "o" ), ( await entities ).First().Properties["_ActivityTime"].StringValue );
//ClearAzureTable( PartitionKey ).Wait();
}
public void AzureStorageProvider_Initialize()
{
XDocument schema = AzureTableStorageProvider.GetDefaultSchema();
AzureTableStorageProvider storage = new AzureTableStorageProvider(new AzureStorageAccountSettings {
ConnectionString = "UseDevelopmentStorage=true",
TableName = "reports",
DefaultPartitionKey = "test",
SchemaDefinition = schema
});
}
public void Schema_Load()
{
XDocument schema = AzureTableStorageProvider.GetDefaultSchema();
Assert.IsNotNull(schema);
var columns = schema.Descendants("Column").ToList();
Assert.IsNotNull(columns[0]);
Assert.IsNotNull(columns[0].Element("AzureColumnName"));
}
internal async Task <VersionRow> GetLastVersion()
{
var tableStorage = new AzureTableStorageProvider(storageAccount);
var topVersion = await tableStorage.CreateQuery <VersionRow>(VersionsTableName).Top(1).Async();
if (topVersion.Any())
{
return(topVersion.First());
}
return(null);
}
internal async Task <VersionRow> AddVersionAsync(string appName, string version, string fileHash)
{
var tableStorage = new AzureTableStorageProvider(storageAccount);
var appVersion = new VersionRow(appName, version, fileHash);
tableStorage.Add(VersionsTableName, appVersion);
await tableStorage.SaveAsync();
return(appVersion);
}
public async Task <Package> GetPackageByNameAndTagAsync(string name)
{
var tableStorage = new AzureTableStorageProvider(storageAccount);
try
{
return(await tableStorage.GetAsync <Package>(PackagesTableName, Package.PACKAGES_PARTITION_NAME, name));
}
catch (EntityDoesNotExistException)
{
return(null);
}
}
internal async Task <PackageTag> AddPackageVersionAsync(string name, string tag, string versionChanges, string fileHash)
{
var tableStorage = new AzureTableStorageProvider(storageAccount);
if (name == Package.PACKAGES_PARTITION_NAME)
{
throw new ArgumentException($"{name} is reserved");
}
Package package = new Package(name, tag, fileHash);
tableStorage.Upsert(PackagesTableName, package); // save as Packages | name@tag
List <PackageTag> allTags = await GetAllEntitiesFromPartitionAsync <PackageTag>(PackagesTableName, name);
if (allTags.Any())
{
if (allTags.Any(t => t.Tag == tag) && allTags.First().Tag != tag) //tag already exist and it is not last
{
throw new ArgumentException($"Tag {tag} already exist and it is not last");
}
else if (allTags.First().Tag == tag)
{
IEnumerable <PackageChange> packageChanges = await GetAllEntitiesFromPartitionAsync <PackageChange>(PackagesFileChangesTableName, name);
foreach (var prevChange in packageChanges.Where(c => c.Tag == tag))
{
tableStorage.Delete(PackagesFileChangesTableName, prevChange);
}
tableStorage.Delete(PackagesTableName, allTags.First());
}
}
PackageTag packageVersion = new PackageTag(name, tag, fileHash);
tableStorage.Upsert(PackagesTableName, packageVersion); //save as name | timestamp (tag, hash)
JObject versionInfoJO = JObject.Parse(versionChanges);
foreach (var fileEntry in versionInfoJO["files"])
{
string path = fileEntry["path"].Value <string>();
string hash = fileEntry["hash"].Value <string>();
string changeType = fileEntry["editType"].Value <string>();
tableStorage.Add(PackagesFileChangesTableName, new PackageChange(name, tag, path, hash, changeType));
}
await tableStorage.SaveAsync();
return(packageVersion);
}
public void TestInitialize()
{
ICloudStorageAccount storageAccount = Configuration.GetTestStorageAccount();
_tableStorageProvider = new AzureTableStorageProvider(storageAccount);
_client = new CloudTableClient(new Uri(storageAccount.TableEndpoint), storageAccount.Credentials);
_tableName = _baseTableName + Guid.NewGuid().ToString().Replace("-", string.Empty);
var table = _client.GetTableReference(_tableName);
table.CreateAsync().Wait();
}
public void AzureStorageProvider_SAS_Save()
{
XDocument schema = AzureTableStorageProvider.GetDefaultSchema();
TelemetryClient client = new TelemetryClient();
ErrorReport report;
try {
throw new GenericException(ErrorCode.GENERIC_CRITICAL_ERROR, "Test Exception Message");
} catch (Exception e) {
report = new ErrorReport(e);
client.AddActiveReport(report);
}
client.UploadActiveReportsAsync(AzureTestStorage_SAS).Wait();
}
public ActionResult Index(SubmitEmail model)
{
if (ModelState.IsValid)
{
var connectionString = GlobalConfig.GetString("BylditStorageAccountConnectionString");
var storageAccount = CloudStorageAccount.Parse(connectionString);
var tableStorageProvider = new AzureTableStorageProvider(new CloudStorageAccountAdapter(storageAccount));
var emailTableName = GlobalConfig.GetString("SubmitEmailTableName");
storageAccount.CreateCloudTableClient().GetTableReference(emailTableName).CreateIfNotExists();
tableStorageProvider.Upsert(emailTableName, model);
tableStorageProvider.Save();
model.Submitted = true;
}
return(View(model));
}
private async Task <List <T> > GetAllEntitiesFromPartitionAsync <T>(string tableName, string partitionName) where T : Model.ITableEntity, new()
{
List <T> result = new List <T>();
var tableStorage = new AzureTableStorageProvider(storageAccount);
string lastRowKey = string.Empty;
while (true)
{
IEnumerable <T> entities = null;
if (string.IsNullOrEmpty(lastRowKey))
{
entities = await tableStorage
.CreateQuery <T>(tableName)
.PartitionKeyEquals(partitionName)
.Top(1000).Async();
}
else
{
entities = await tableStorage
.CreateQuery <T>(tableName)
.PartitionKeyEquals(partitionName)
.RowKeyFrom(lastRowKey).Exclusive()
.Top(1000).Async();
}
result.AddRange(entities);
if (entities.Count() < 1000)
{
break;
}
else
{
lastRowKey = entities.Last().RowKey;
}
}
return(result);
}
internal async Task <List <VersionRow> > GetLastVersions(int count)
{
var tableStorage = new AzureTableStorageProvider(storageAccount);
return((await tableStorage.CreateQuery <VersionRow>(VersionsTableName).Top(count).Async()).ToList());
}
