private T ConvertGetItemResponse <T>(GetItemRequest request, DynamoMetadataType table) { var response = Exec(() => DynamoDb.GetItem(request), rethrowExceptions: throwNotFoundExceptions); if (!response.IsItemSet) { return(default);
public long DescribeItemCount <T>() { var table = DynamoMetadata.GetTable <T>(); var response = Exec(() => DynamoDb.DescribeTable(new DescribeTableRequest(table.Name))); return(response.Table.ItemCount); }
private async Task <List <Table> > ExpandTablePatterns(DynamoDb dynamoDb, string alertingGroupName) { var tablesWithoutPatterns = dynamoDb.Tables .Where(t => string.IsNullOrWhiteSpace(t.Pattern)) .ToList(); var patterns = dynamoDb.Tables .Where(t => !string.IsNullOrWhiteSpace(t.Pattern)) .ToList(); var tablesFromPatterns = new List <Table>(); foreach (var tablePattern in patterns) { var matches = await GetPatternMatches(tablePattern, alertingGroupName); // filter out duplicates matches = matches .Where(match => tablesFromPatterns.All(t => t.Name != match.Name)) .ToList(); matches = matches .Where(match => tablesWithoutPatterns.All(t => t.Name != match.Name)) .ToList(); tablesFromPatterns.AddRange(matches); } return(tablesWithoutPatterns .Union(tablesFromPatterns) .ToList()); }
public async Task UpdateItemAsync <T>(DynamoUpdateItem update, CancellationToken token = default) { var request = ToUpdateItemRequest <T>(update); await ExecAsync(async() => await DynamoDb.UpdateItemAsync(request, token).ConfigAwait()).ConfigAwait(); }
public void PutItems <T>(IEnumerable <T> items) { var table = DynamoMetadata.GetTable <T>(); var remaining = items.ToList(); PopulateMissingHashes(table, remaining); while (remaining.Count > 0) { var batchSize = Math.Min(remaining.Count, MaxWriteBatchSize); var nextBatch = remaining.GetRange(0, batchSize); remaining.RemoveRange(0, batchSize); var putItems = nextBatch.Map(x => new WriteRequest( new PutRequest(Converters.ToAttributeValues(this, x, table)))); var request = new BatchWriteItemRequest(new Dictionary <string, List <WriteRequest> > { { table.Name, putItems } }); var response = Exec(() => DynamoDb.BatchWriteItem(request)); var i = 0; while (response.UnprocessedItems.Count > 0) { response = Exec(() => DynamoDb.BatchWriteItem(new BatchWriteItemRequest(response.UnprocessedItems))); if (response.UnprocessedItems.Count > 0) { i.SleepBackOffMultiplier(); } } } }
private List <T> ConvertBatchGetItemResponse <T>(DynamoMetadataType table, KeysAndAttributes getItems) { var to = new List <T>(); var request = new BatchGetItemRequest(new Dictionary <string, KeysAndAttributes> { { table.Name, getItems } }); var response = Exec(() => DynamoDb.BatchGetItem(request)); List <Dictionary <string, AttributeValue> > results; if (response.Responses.TryGetValue(table.Name, out results)) { results.Each(x => to.Add(Converters.FromAttributeValues <T>(table, x))); } var i = 0; while (response.UnprocessedKeys.Count > 0) { response = Exec(() => DynamoDb.BatchGetItem(new BatchGetItemRequest(response.UnprocessedKeys))); if (response.Responses.TryGetValue(table.Name, out results)) { results.Each(x => to.Add(Converters.FromAttributeValues <T>(table, x))); } if (response.UnprocessedKeys.Count > 0) { i.SleepBackOffMultiplier(); } } return(to); }
public long Increment <T>(object hash, string fieldName, long amount = 1) { var type = DynamoMetadata.GetType <T>(); var request = new UpdateItemRequest { TableName = type.Name, Key = Converters.ToAttributeKeyValue(this, type.HashKey, hash), AttributeUpdates = new Dictionary <string, AttributeValueUpdate> { { fieldName, new AttributeValueUpdate { Action = AttributeAction.ADD, Value = new AttributeValue { N = amount.ToString() } } } }, ReturnValues = ReturnValue.ALL_NEW, }; var response = DynamoDb.UpdateItem(request); return(response.Attributes.Count > 0 ? Convert.ToInt64(response.Attributes[fieldName].N) : 0); }
public List <T> Scan <T>(ScanRequest request, int limit) { var to = new List <T>(); if (request.Limit == default(int)) { request.Limit = limit; } ScanResponse response = null; do { if (response != null) { request.ExclusiveStartKey = response.LastEvaluatedKey; } response = Exec(() => DynamoDb.Scan(request)); var results = response.ConvertAll <T>(); foreach (var result in results) { to.Add(result); if (to.Count >= limit) { break; } } } while (!response.LastEvaluatedKey.IsEmpty() && to.Count < limit); return(to); }
private async Task <bool> TableExist() { var tables = await DynamoDb.ListTablesAsync(); var existTable = tables.TableNames.Contains(TableName); return(existTable); }
public async Task <bool> TableExist(string tableName) { var tables = await DynamoDb.ListTablesAsync(); var existTable = tables.TableNames.Contains(tableName); return(existTable); }
protected virtual void Dispose(bool disposing) { if (DynamoDb != null) { DynamoDb.Dispose(); DynamoDb = null; } }
public void ClearEntities() { //TODO :DI using (IDal database = new DynamoDb()) { database.ClearEntities(); } }
public void UpdateItem <T>(DynamoUpdateItem update) { var table = DynamoMetadata.GetTable <T>(); var request = new UpdateItemRequest { TableName = table.Name, Key = Converters.ToAttributeKeyValue(this, table, update.Hash, update.Range), AttributeUpdates = new Dictionary <string, AttributeValueUpdate>(), ReturnValues = ReturnValue.NONE, }; if (update.Put != null) { foreach (var entry in update.Put) { var field = table.GetField(entry.Key); if (field == null) { continue; } request.AttributeUpdates[field.Name] = new AttributeValueUpdate( Converters.ToAttributeValue(this, field.Type, field.DbType, entry.Value), DynamoAttributeAction.Put); } } if (update.Add != null) { foreach (var entry in update.Add) { var field = table.GetField(entry.Key); if (field == null) { continue; } request.AttributeUpdates[field.Name] = new AttributeValueUpdate( Converters.ToAttributeValue(this, field.Type, field.DbType, entry.Value), DynamoAttributeAction.Add); } } if (update.Delete != null) { foreach (var key in update.Delete) { var field = table.GetField(key); if (field == null) { continue; } request.AttributeUpdates[field.Name] = new AttributeValueUpdate(null, DynamoAttributeAction.Delete); } } Exec(() => DynamoDb.UpdateItem(request)); }
private async Task CreateIfNotExist(CreateTableRequest request) { if (await TableExist()) { return; } await DynamoDb.CreateTableAsync(request); }
protected Task <CreateTableResponse> CreateTestTable(string tableName = null) { var postTableCreateRequest = new CreateTableRequest { AttributeDefinitions = new List <AttributeDefinition> { new AttributeDefinition { AttributeName = nameof(MovieEntity.DirectorId), AttributeType = ScalarAttributeType.S }, new AttributeDefinition { AttributeName = nameof(MovieEntity.CreateDate), AttributeType = ScalarAttributeType.S }, new AttributeDefinition() { AttributeName = nameof(MovieEntity.MovieId), AttributeType = ScalarAttributeType.S } }, TableName = tableName ?? TestTableName, KeySchema = new List <KeySchemaElement>() { new KeySchemaElement() { AttributeName = nameof(MovieEntity.DirectorId), KeyType = KeyType.HASH }, new KeySchemaElement() { AttributeName = nameof(MovieEntity.CreateDate), KeyType = KeyType.RANGE } }, GlobalSecondaryIndexes = new List <GlobalSecondaryIndex> { new GlobalSecondaryIndex { Projection = new Projection { ProjectionType = ProjectionType.ALL }, IndexName = TestConstants.MoiveTableMovieIdGsi, KeySchema = new List <KeySchemaElement> { new KeySchemaElement { AttributeName = nameof(MovieEntity.MovieId), KeyType = KeyType.HASH } }, ProvisionedThroughput = new ProvisionedThroughput { ReadCapacityUnits = 5, WriteCapacityUnits = 5 } } }, ProvisionedThroughput = new ProvisionedThroughput { ReadCapacityUnits = 5, WriteCapacityUnits = 6 }, }; return(DynamoDb.CreateTableAsync(postTableCreateRequest)); }
public void Close() { if (DynamoDb == null) { return; } DynamoDb.Dispose(); DynamoDb = null; }
public T Get(long Id) { try { T item = DynamoDb.GetItem <T>(Id); return(item); } catch { return(null); } }
public List <T> GetAll() { try { List <T> Items = DynamoDb.GetAll <T>(); return(Items); } catch (Exception ex) { return(new List <T>()); } }
public bool SaveToDatabase(IList <Entity> entities) { bool result; //TODO :DI using (IDal database = new DynamoDb()) { result = database.InsertEntities(entities); } return(result); }
private T ConvertGetItemResponse <T>(GetItemRequest request, DynamoMetadataType table) { var response = Exec(() => DynamoDb.GetItem(request), rethrowExceptions: throwNotFoundExceptions); if (!response.IsItemSet) { return(default(T)); } var attributeValues = response.Item; return(Converters.FromAttributeValues <T>(table, attributeValues)); }
public bool UpdateItem <T>(UpdateExpression <T> update) { try { Exec(() => DynamoDb.UpdateItem(update)); return(true); } catch (ConditionalCheckFailedException) { return(false); } }
public Entity SearchEntity(Entity entity) { //TODO :DI Entity result; Enum.TryParse(entity.Type, out EntityType type); using (IDal database = new DynamoDb()) { result = database.QueryEntity(type, entity.Id, entity.TimeStamp); } return(result); }
public async Task <bool> UpdateItemAsync <T>(UpdateExpression <T> update, CancellationToken token = default) { try { await ExecAsync(async() => await DynamoDb.UpdateItemAsync(update, token).ConfigAwait()).ConfigAwait(); return(true); } catch (ConditionalCheckFailedException) { return(false); } }
private static WatchmanConfiguration Config() { var group = new DynamoDb { Tables = new List <Table> { new Table { Pattern = ".*", Threshold = 0.75, MonitorWrites = false } } }; return(AlertingGroupData.WrapDynamo(group)); }
private static WatchmanConfiguration Config() { var ag = new DynamoDb { Tables = new List <Table> { new Table { Name = "authentication-tokens" } } }; return(AlertingGroupData.WrapDynamo(ag)); }
private static WatchmanConfiguration CatchAllConfig() { var catchAll = new DynamoDb { Tables = new List <Table> { new Table { Pattern = ".*" } } }; return(AlertingGroupData.WrapDynamo(catchAll)); }
private static WatchmanConfiguration Config() { var dynamoConfig = new DynamoDb { Tables = new List <Table> { new Table { Pattern = "nomatchwillbefoundforthis" } } }; return(AlertingGroupData.WrapDynamo(dynamoConfig)); }
public bool WaitForTablesToBeReady(IEnumerable <string> tableNames, TimeSpan?timeout = null) { var pendingTables = new List <string>(tableNames); if (pendingTables.Count == 0) { return(true); } var startAt = DateTime.UtcNow; do { try { var responses = pendingTables.Map(x => Exec(() => DynamoDb.DescribeTable(new DescribeTableRequest(x)))); foreach (var response in responses) { if (response.Table.TableStatus == DynamoStatus.Active) { pendingTables.Remove(response.Table.TableName); } } if (Log.IsDebugEnabled) { Log.Debug($"Tables Pending: {pendingTables.ToJsv()}"); } if (pendingTables.Count == 0) { return(true); } if (timeout != null && DateTime.UtcNow - startAt > timeout.Value) { return(false); } Thread.Sleep(PollTableStatus); } catch (ResourceNotFoundException) { // DescribeTable is eventually consistent. So you might // get resource not found. So we handle the potential exception. } } while (true); }
public T PutItem <T>(T value, bool returnOld = false) { var table = DynamoMetadata.GetTable <T>(); var request = new PutItemRequest { TableName = table.Name, Item = Converters.ToAttributeValues(this, value, table), ReturnValues = returnOld ? ReturnValue.ALL_OLD : ReturnValue.NONE, }; var response = Exec(() => DynamoDb.PutItem(request)); if (response.Attributes.IsEmpty()) { return(default);
private static WatchmanConfiguration Config() { var allTablesReadOnly = new DynamoDb { MonitorThrottling = true, Tables = new List <Table> { new Table { Pattern = ".*", Threshold = 0.75, MonitorWrites = false } } }; return(AlertingGroupData.WrapDynamo(allTablesReadOnly)); }