private async Task <CloudTable> CreateTableIfNotExists() { _cloudStorageAccount = CloudStorageAccount.Parse(_connstionString); var cloudTableClient = _cloudStorageAccount.CreateCloudTableClient(); CloudTable table = cloudTableClient.GetTableReference(_tableName); try { await table.CreateAsync(); } catch (StorageException storageException) { //We do not fire exception if table exists - there is no need in such actions if (storageException.RequestInformation.HttpStatusCode != (int)HttpStatusCode.Conflict && storageException.RequestInformation.ExtendedErrorInformation.ErrorCode != TableErrorCodeStrings.TableAlreadyExists) { await _log?.WriteFatalErrorAsync("Table storage: " + _tableName, "CreateTable error", "", storageException); throw; } } catch (Exception exception) { await _log?.WriteFatalErrorAsync("Table storage: " + _tableName, "CreateTable error", "unknown case", exception); throw; } return(table); }
public void TableGetPermissionsRequestOptionsOperationContextCancellationTokenTask() { CloudTableClient tableClient = GenerateCloudTableClient(); string tableName = GenerateRandomTableName(); CloudTable table = tableClient.GetTableReference(tableName); TableRequestOptions requestOptions = new TableRequestOptions(); OperationContext operationContext = new OperationContext(); CancellationToken cancellationToken = CancellationToken.None; try { table.CreateAsync().Wait(); var entity = new BaseEntity("PK", "RK"); entity.Populate(); table.ExecuteAsync(TableOperation.Insert(entity)).Wait(); TablePermissions expected = new TablePermissions(); TablePermissions actual = table.GetPermissionsAsync(requestOptions, operationContext, cancellationToken).Result; AssertPermissionsEqual(expected, actual); } finally { table.DeleteIfExistsAsync().Wait(); } }
public void TableSetPermissionsPermissionsTask() { CloudTableClient tableClient = GenerateCloudTableClient(); string tableName = GenerateRandomTableName(); CloudTable table = tableClient.GetTableReference(tableName); TablePermissions permissions = new TablePermissions(); permissions.SharedAccessPolicies.Add(Guid.NewGuid().ToString(), new SharedAccessTablePolicy() { Permissions = SharedAccessTablePermissions.Query, SharedAccessStartTime = DateTimeOffset.Now.Add(new TimeSpan(-1, 0, 0)), SharedAccessExpiryTime = DateTimeOffset.Now.Add(new TimeSpan(1, 0, 0)) }); try { table.CreateAsync().Wait(); var entity = new BaseEntity("PK", "RK"); entity.Populate(); table.ExecuteAsync(TableOperation.Insert(entity)).Wait(); table.SetPermissionsAsync(permissions); } finally { table.DeleteIfExistsAsync().Wait(); } }
internal async Task <ResultObject> HandleAsync(CreateEventCommand command) { if (!await _cloudTable.ExistsAsync()) { await _cloudTable.CreateAsync(); } // Validation logic goes here... var model = CreateEventModel(command); var operation = TableOperation.Insert(model); try { var tableResult = await _cloudTable.ExecuteAsync(operation); if (tableResult.HttpStatusCode == 204 && tableResult.Result is EventModel eventModel) { return new ResultObject { Success = true, Result = eventModel.RowKey, Message = string.Empty } } ; else { return new ResultObject { Success = false, Result = null, Message = "Unable to create entity" } }; } catch (StorageException) { throw; } }
public void TableSetPermissionsPermissionsRequestOptionsOperationContextCancellationTokenTask() { CloudTableClient tableClient = GenerateCloudTableClient(); string tableName = GenerateRandomTableName(); CloudTable table = tableClient.GetTableReference(tableName); TablePermissions permissions = new TablePermissions(); TableRequestOptions requestOptions = new TableRequestOptions(); OperationContext operationContext = new OperationContext(); CancellationToken cancellationToken = CancellationToken.None; permissions.SharedAccessPolicies.Add(Guid.NewGuid().ToString(), new SharedAccessTablePolicy() { Permissions = SharedAccessTablePermissions.Query, SharedAccessStartTime = DateTimeOffset.Now.Add(new TimeSpan(-1, 0, 0)), SharedAccessExpiryTime = DateTimeOffset.Now.Add(new TimeSpan(1, 0, 0)) }); try { table.CreateAsync().Wait(); table.ExecuteAsync(TableOperation.Insert(new BaseEntity("PK", "RK"))).Wait(); table.SetPermissionsAsync(permissions, requestOptions, operationContext, cancellationToken); } finally { table.DeleteIfExistsAsync().Wait(); } }
public static async Task <CloudTable> CreateTableAsync(string tableName) { var connectionString = "DefaultEndpointsProtocol=https;AccountName=Your storage account name;AccountKey=Your account key;EndpointSuffix=core.windows.net"; // Retrieve storage account information from connection string. CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString); // Create a table client for interacting with the table service CloudTableClient tableClient = storageAccount.CreateCloudTableClient(new TableClientConfiguration()); Console.WriteLine("Create a Table for the demo\n"); // Create a table client for interacting with the table service CloudTable table = tableClient.GetTableReference(tableName); if (await table.ExistsAsync()) { Console.WriteLine("Table {0} already exists \n", tableName); } else { await table.CreateAsync(); Console.WriteLine("Table {0} created \n", tableName); } Console.WriteLine(); return(table); }
private Task UpdateTableAsync(PartitionContext context, string messagingtext) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(Properties.Settings.Default.StorageConnectionString); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); CloudTable heartbeatTable = tableClient.GetTableReference("heartbeat"); if (heartbeatTable == null) { heartbeatTable.CreateAsync().Wait(); } MemoryStream memStream = new MemoryStream(Encoding.UTF8.GetBytes(messagingtext)); StreamReader reader = new StreamReader(memStream); string line = null; while ((line = reader.ReadLine()) != null) { var json = JsonConvert.DeserializeObject(line); JObject jParse = JObject.Parse(Convert.ToString(json)); string DeviceID = (string)jParse["device_id"]; string lastdatarecieved = (string)jParse["lastdatarecieved"]; HeartbeatEntity heartbeatObj = Task.Factory.StartNew(() => JsonConvert.DeserializeObject <HeartbeatEntity>(line)).Result; TableOperation insertorreplace = TableOperation.InsertOrReplace(heartbeatObj); Task.Factory.StartNew(() => heartbeatTable.ExecuteAsync(insertorreplace)); Console.WriteLine(DeviceID + ", " + lastdatarecieved + ", " + context.Lease.PartitionId); } return(Task.FromResult(true)); }
public static async Task <CloudTable> CreateTableAsync(string tableName) { StorageCredentials creds = new StorageCredentials(accountName, accountKey); CloudStorageAccount account = new CloudStorageAccount(creds, useHttps: true); CloudTableClient client = account.CreateCloudTableClient(); CloudTable table = client.GetTableReference(tableName); await table.CreateAsync(); return(table); }
private static async Task <CloudTable> GetTable() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(Environment.GetEnvironmentVariable("AzureWebJobsStorage")); CloudTableClient client = storageAccount.CreateCloudTableClient(); CloudTable table = client.GetTableReference("MockApi"); if (!await table.ExistsAsync()) { await table.CreateAsync(); } return(table); }
public async Task TestInitialize() { CloudTable table = CloudStorageAccount .DevelopmentStorageAccount .CreateCloudTableClient() .GetTableReference("DetectorTestingEventStore"); await table.DeleteIfExistsAsync(); await table.CreateAsync(); Table = table; }
public async Task CloudTableExtensionsTest() { // Arrange var permissions = new TablePermissions(); permissions.SharedAccessPolicies.Add("default", new SharedAccessTablePolicy { Permissions = SharedAccessTablePermissions.Query, SharedAccessExpiryTime = DateTimeOffset.UtcNow, SharedAccessStartTime = DateTimeOffset.UtcNow }); // Act // Create table await _cloudTable.CreateAsync(); // Create table bool createIfNotExistsResult = await _cloudTable.CreateIfNotExistsAsync(); // Check whether table exists bool existsResult = await _cloudTable.ExistsAsync(); // Set & get permissions await _cloudTable.SetPermissionsAsync(permissions); TablePermissions permissionsResult = await _cloudTable.GetPermissionsAsync(); // Delete table await _cloudTable.DeleteAsync(); bool deleteIfExistsResult = await _cloudTable.DeleteIfExistsAsync(); // Assert Assert.False(createIfNotExistsResult); Assert.True(existsResult); Assert.NotNull(permissionsResult); Assert.NotNull(permissionsResult.SharedAccessPolicies); Assert.Equal(permissionsResult.SharedAccessPolicies.Count, permissions.SharedAccessPolicies.Count); foreach (var policy in permissionsResult.SharedAccessPolicies) { Assert.Contains(policy.Key, permissions.SharedAccessPolicies.Keys); SharedAccessTablePolicy value = permissions.SharedAccessPolicies[policy.Key]; Assert.Equal(policy.Value.Permissions, value.Permissions); } Assert.False(deleteIfExistsResult); }
public Task CreateTableAsync(Type entityType, bool ignoreErrorIfExists = true) { // Retrieve a reference to the table. CloudTable table = GetTableReference(GetTableName(entityType)); if (ignoreErrorIfExists) { // Create the table if it doesn't exist. return(table.CreateIfNotExistsAsync()); } else { // Create table and throw error return(table.CreateAsync()); } }
private async Task <CloudTable> GetTable() { if (!_table.Exists()) { try { await _table.CreateAsync(); } catch (Exception exception) { Trace.TraceError(exception.ToString()); } } return(_table); }
private async Task CreateAzureTableAsync(CloudTable table) { try { await table.CreateAsync(); } catch (StorageException ex) when(ex.RequestInformation.HttpStatusCode == 409) { await Task.Delay(20000); await CreateAzureTableAsync(table); } catch (Exception) { throw; } }
public async Task FlushAllPendingEvents_sends_all_pending_events() { // Arrange await s_eventTable.DeleteIfExistsAsync(); await s_eventTable.CreateAsync(); var messageBus = new MessageLogger(); var sut = new AzureEventPublisher(s_eventTable, s_serializer, messageBus); var expected = new List <Envelope <IDomainEvent> >(); var fixture = new Fixture(); var userIds = fixture.CreateMany <Guid>().ToList(); foreach (Guid userId in userIds) { var user = new FakeUser(userId, fixture.Create <string>()); user.ChangeUsername(fixture.Create <string>()); string operationId = fixture.Create <string>(); var correlationId = Guid.NewGuid(); string contributor = fixture.Create <string>(); var envelopes = new List <Envelope <IDomainEvent> >( from message in user.FlushPendingEvents() let messageId = Guid.NewGuid() select new Envelope <IDomainEvent>(messageId, message, operationId, correlationId, contributor)); expected.AddRange(envelopes); var batch = new TableBatchOperation(); foreach (Envelope <IDomainEvent> envelope in envelopes) { batch.Insert(PendingEvent.Create(typeof(FakeUser), envelope, s_serializer)); } await s_eventTable.ExecuteBatchAsync(batch); } // Act await sut.FlushAllPendingEvents(CancellationToken.None); // Assert messageBus.Log.ShouldAllBeEquivalentTo(expected); }
public static async Task ClassInitialize(TestContext context) { try { CloudTableClient tableClient = CloudStorageAccount.DevelopmentStorageAccount.CreateCloudTableClient(); s_eventTable = tableClient.GetTableReference("AzureEventStoreTestEventStore"); await s_eventTable.DeleteIfExistsAsync( new TableRequestOptions { RetryPolicy = new NoRetry() }, operationContext : default); await s_eventTable.CreateAsync(); } catch (StorageException exception) { context.WriteLine($"{exception}"); Assert.Inconclusive("Could not connect to Azure Storage Emulator. See the output for details. Refer to the following URL for more information: http://go.microsoft.com/fwlink/?LinkId=392237"); } }
private static async Task CheckAndInitializeTable <T>(CloudTableClient tableClient, string funcAppDirectory, string seedFilename, ILogger log) where T : EntityBase, new() { var tableName = typeof(T).Name.ToLower(); CloudTable table = tableClient.GetTableReference(tableName); var exists = await table.ExistsAsync(); if (exists) { return; } await table.CreateAsync(); var rowNumber = 0; var batchOperation = new TableBatchOperation(); var seedPath = Path.Combine(funcAppDirectory, Constants.Data.Directory, seedFilename); var seedJson = File.ReadAllText(seedPath); var seedEntries = JsonConvert.DeserializeObject <ICollection <T> >(seedJson); foreach (var entry in seedEntries) { batchOperation.Add(TableOperation.InsertOrReplace(entry)); if (batchOperation.Count > 99) { table.ExecuteBatch(batchOperation); batchOperation.Clear(); } rowNumber++; } if (batchOperation.Count > 0) { table.ExecuteBatch(batchOperation); batchOperation.Clear(); } log.LogInformation($"{seedEntries.Count} {tableName}s initially seeded"); }
public void TableGetPermissionsTask() { CloudTableClient tableClient = GenerateCloudTableClient(); string tableName = GenerateRandomTableName(); CloudTable table = tableClient.GetTableReference(tableName); try { table.CreateAsync().Wait(); table.ExecuteAsync(TableOperation.Insert(new BaseEntity("PK", "RK"))).Wait(); TablePermissions expected = new TablePermissions(); TablePermissions actual = table.GetPermissionsAsync().Result; AssertPermissionsEqual(expected, actual); } finally { table.DeleteIfExistsAsync().Wait(); } }
async Task ExecuteCreateTableAsync() { if (IsBusy) { return; } if (!ReadyToSave) { Logger.Report(new Exception("Create table called when ReadyToSave was false"), "Method", "ExecuteCreateTableAsync"); return; } if (tableName.Length < 3 || tableName.Length > 63 || !Regex.IsMatch(tableName, @"^[A-Za-z][A-Za-z0-9]*$")) { MessagingService.Current.SendMessage <MessagingServiceAlert>(MessageKeys.Message, new MessagingServiceAlert { Title = "Table name is invalid", Message = "Table names must be between 3 and 63 chars, only contain letters and numbers, and start with a letter.", Cancel = "OK" }); return; } IProgressDialog savingDialog = UserDialogs.Loading("Saving Table"); savingDialog.Show(); try { IsBusy = true; string connectionString = Constants.StorageConnectionString; connectionString = connectionString.Replace("<ACCOUNTNAME>", SelectedStorageAccount.Name); connectionString = connectionString.Replace("<ACCOUNTKEY>", SelectedStorageAccount.PrimaryKey); CloudStorageAccount sa = CloudStorageAccount.Parse(connectionString); var tableClient = sa.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference(tableName); if (table == null) { Console.WriteLine("Table is null"); } if (await table.ExistsAsync()) { MessagingService.Current.SendMessage <MessagingServiceAlert>(MessageKeys.Message, new MessagingServiceAlert { Title = "Table Exists", Message = "A table with the name \"" + TableName + "\" already exists in this storage account.", Cancel = "OK" }); return; } else { await table.CreateAsync(); var realm = App.GetRealm(); var storageAccountName = selectedStorageAccount.Name; realm.Write(() => { realm.Add(new RealmCloudTable(table.Name, selectedStorageAccount.Name, table.Uri.ToString())); }); if (tablesVM != null) { tablesVM.AddTable(new ASECloudTable(table, selectedStorageAccount.Name)); App.Logger.Track(AppEvent.CreatedTable.ToString()); } //This is here and in finally so we'll dismiss this before popping the page so the //Loader doesn't stay longer than the popup if (savingDialog != null) { if (savingDialog.IsShowing) { savingDialog.Hide(); } savingDialog.Dispose(); } await PopupNavigation.PopAsync(); } } catch (Exception ex) { Logger.Report(ex, "Method", "ExecuteCreateTableAsync"); MessagingService.Current.SendMessage(MessageKeys.Error, ex); } finally { IsBusy = false; if (savingDialog != null) { if (savingDialog.IsShowing) { savingDialog.Hide(); } savingDialog.Dispose(); } } return; }
private async Task prepPointHistory(long pointid) { CloudTable cloudTable = null; Dictionary <int, DateTime?> res = new Dictionary <int, DateTime?>(); var StartHistory = _startHistoryDataDateUtc; //.ToString("yyyyMM"); var Now = DateTime.UtcNow; //.ToString("yyyyMM"); long sampCount = 0; long sampCountTimer = DateTime.UtcNow.Ticks; int expCount = 3; string presentTableName = ""; while (((Now.Ticks - StartHistory.Ticks) / TimeSpan.TicksPerSecond) > 0) { // Check that table exists for month var tableName = "P" + support.padZeroOnItem(6, pointid) + StartHistory.ToString("yyyyMM"); if (presentTableName != tableName) { Exception tableExp = null; while (expCount > 0) { try { // Check if table exists cloudTable = _cloudTableClient.GetTableReference(tableName); if (!cloudTable.Exists()) { cloudTable.CreateAsync().Wait(); } tableExp = null; break; } catch (Exception ex) { Console.WriteLine((DateTime.Now.ToString("HH:mm:ss.fff") + ": Table Error " + ex.Message)); await Task.Delay(1000 *(3 - expCount)); tableExp = ex; expCount--; } } if (tableExp != null) { throw tableExp; } presentTableName = tableName; } // Generate new partion, thats 1 hour of 60 rows var tuple = generatePartionDataSetForPoint(pointid, StartHistory); StartHistory = tuple.Item2; var rows = tuple.Item1; expCount = 3; Exception insertExp = null; while (expCount > 0) { try { // Insert into Table source with batch var t = InsertBatchEntiy(cloudTable, rows); t.Wait(); var insertRes = t.Result; insertExp = null; Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + ": Inserted Blockstart:" + rows[0].RowKey + " " + rows.Count + " rows"); sampCount += (rows.Count * (60 * 1000 / _scanRateMs)); break; } catch (Exception ex) { insertExp = ex; expCount--; Console.WriteLine((DateTime.Now.ToString("HH:mm:ss.fff") + ": Error " + ex.Message)); await Task.Delay(2000); } } if (insertExp != null) { // Failed insert Console.WriteLine((DateTime.Now.ToString("HH:mm:ss.fff") + ": FAILED insert " + insertExp.Message)); } } Console.WriteLine("Point " + pointid + " insert " + sampCount + " samps in " + ((DateTime.UtcNow.Ticks - sampCountTimer) / TimeSpan.TicksPerSecond)); }
public static Task CreateAsync(this CloudTable tbl, CancellationToken token) { return(tbl.CreateAsync(null, null, token)); }
public void Create() { table.CreateAsync().Wait(); }
public Task CreateAsync(CancellationToken cancellationToken) { return(_table.CreateAsync(cancellationToken)); }
public Task CreateAsync(TableRequestOptions requestOptions = null, OperationContext operationContext = null) { return(cloudTableImpl.CreateAsync(requestOptions, operationContext)); }