public async Task DeleteMembershipTableEntries(string clusterId)
        {
            try
            {
                var keys = new Dictionary<string, AttributeValue> { { $":{SiloInstanceRecord.DEPLOYMENT_ID_PROPERTY_NAME}", new AttributeValue(clusterId) } };
                var records = await storage.QueryAsync(TABLE_NAME_DEFAULT_VALUE, keys, $"{SiloInstanceRecord.DEPLOYMENT_ID_PROPERTY_NAME} = :{SiloInstanceRecord.DEPLOYMENT_ID_PROPERTY_NAME}", item => new SiloInstanceRecord(item));

                var toDelete = new List<Dictionary<string, AttributeValue>>();
                foreach (var record in records)
                {
                    toDelete.Add(record.GetKeys());
                }

                List<Task> tasks = new List<Task>();
                foreach (var batch in toDelete.BatchIEnumerable(MAX_BATCH_SIZE))
                {
                    tasks.Add(storage.DeleteEntriesAsync(TABLE_NAME_DEFAULT_VALUE, batch));
                }
                await Task.WhenAll(tasks);
            }
            catch (Exception exc)
            {
                logger.Error(ErrorCode.MembershipBase, string.Format("Unable to delete membership records on table {0} for clusterId {1}: Exception={2}",
                    TABLE_NAME_DEFAULT_VALUE, clusterId, exc));
                throw;
            }
        }
Example #2
0
        internal async Task <int> DeleteTableEntries(string deploymentId)
        {
            if (deploymentId == null)
            {
                throw new ArgumentNullException("deploymentId");
            }

            var entries = await storage.ReadAllTableEntriesForPartitionAsync(deploymentId);

            var entriesList = new List <Tuple <SiloInstanceTableEntry, string> >(entries);

            if (entriesList.Count <= AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS)
            {
                await storage.DeleteTableEntriesAsync(entriesList);
            }
            else
            {
                List <Task> tasks = new List <Task>();
                foreach (var batch in entriesList.BatchIEnumerable(AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS))
                {
                    tasks.Add(storage.DeleteTableEntriesAsync(batch));
                }
                await Task.WhenAll(tasks);
            }
            return(entriesList.Count());
        }
        public async Task DeleteMembershipTableEntries(string clusterId)
        {
            try
            {
                var keys = new Dictionary <string, AttributeValue> {
                    { $":{SiloInstanceRecord.DEPLOYMENT_ID_PROPERTY_NAME}", new AttributeValue(clusterId) }
                };
                var records = await storage.QueryAsync(this.options.TableName, keys, $"{SiloInstanceRecord.DEPLOYMENT_ID_PROPERTY_NAME} = :{SiloInstanceRecord.DEPLOYMENT_ID_PROPERTY_NAME}", item => new SiloInstanceRecord(item));

                var toDelete = new List <Dictionary <string, AttributeValue> >();
                foreach (var record in records.results)
                {
                    toDelete.Add(record.GetKeys());
                }

                List <Task> tasks = new List <Task>();
                foreach (var batch in toDelete.BatchIEnumerable(MAX_BATCH_SIZE))
                {
                    tasks.Add(storage.DeleteEntriesAsync(this.options.TableName, batch));
                }
                await Task.WhenAll(tasks);
            }
            catch (Exception exc)
            {
                this.logger.LogError(
                    (int)ErrorCode.MembershipBase,
                    exc,
                    "Unable to delete membership records on table {TableName} for ClusterId {ClusterId}",
                    this.options.TableName,
                    clusterId);
                throw;
            }
        }
        public async Task DeleteMembershipTableEntries(string deploymentId)
        {
            try
            {
                var keys = new Dictionary<string, AttributeValue> { { $":{SiloInstanceRecord.DEPLOYMENT_ID_PROPERTY_NAME}", new AttributeValue(deploymentId) } };
                var records = await storage.QueryAsync(TABLE_NAME_DEFAULT_VALUE, keys, $"{SiloInstanceRecord.DEPLOYMENT_ID_PROPERTY_NAME} = :{SiloInstanceRecord.DEPLOYMENT_ID_PROPERTY_NAME}", item => new SiloInstanceRecord(item));

                var toDelete = new List<Dictionary<string, AttributeValue>>();
                foreach (var record in records)
                {
                    toDelete.Add(record.GetKeys());
                }

                List<Task> tasks = new List<Task>();
                foreach (var batch in toDelete.BatchIEnumerable(MAX_BATCH_SIZE))
                {
                    tasks.Add(storage.DeleteEntriesAsync(TABLE_NAME_DEFAULT_VALUE, batch));
                }
                await Task.WhenAll(tasks);
            }
            catch (Exception exc)
            {
                logger.Error(ErrorCode.MembershipBase, string.Format("Unable to delete membership records on table {0} for deploymentId {1}: Exception={2}",
                    TABLE_NAME_DEFAULT_VALUE, deploymentId, exc));
                throw;
            }
        }
 private async Task DeleteEntriesBatch(List <Tuple <SiloInstanceTableEntry, string> > entriesList)
 {
     if (entriesList.Count <= this.storagePolicyOptions.MaxBulkUpdateRows)
     {
         await storage.DeleteTableEntriesAsync(entriesList);
     }
     else
     {
         var tasks = new List <Task>();
         foreach (var batch in entriesList.BatchIEnumerable(this.storagePolicyOptions.MaxBulkUpdateRows))
         {
             tasks.Add(storage.DeleteTableEntriesAsync(batch));
         }
         await Task.WhenAll(tasks);
     }
 }
 public async Task UnregisterMany(List <GrainAddress> addresses)
 {
     if (addresses.Count <= this.tableDataManager.StoragePolicyOptions.MaxBulkUpdateRows)
     {
         await UnregisterManyBlock(addresses);
     }
     else
     {
         var tasks = new List <Task>();
         foreach (var subList in addresses.BatchIEnumerable(this.tableDataManager.StoragePolicyOptions.MaxBulkUpdateRows))
         {
             tasks.Add(UnregisterManyBlock(subList));
         }
         await Task.WhenAll(tasks);
     }
 }
 private async Task DeleteEntriesBatch(List <Tuple <SiloInstanceTableEntry, string> > entriesList)
 {
     if (entriesList.Count <= AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS)
     {
         await storage.DeleteTableEntriesAsync(entriesList);
     }
     else
     {
         var tasks = new List <Task>();
         foreach (var batch in entriesList.BatchIEnumerable(AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS))
         {
             tasks.Add(storage.DeleteTableEntriesAsync(batch));
         }
         await Task.WhenAll(tasks);
     }
 }
Example #8
0
 public async Task UnregisterMany(List <GrainAddress> addresses)
 {
     if (addresses.Count <= AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS)
     {
         await UnregisterManyBlock(addresses);
     }
     else
     {
         var tasks = new List <Task>();
         foreach (var subList in addresses.BatchIEnumerable(AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS))
         {
             tasks.Add(UnregisterManyBlock(subList));
         }
         await Task.WhenAll(tasks);
     }
 }
Example #9
0
        internal async Task <int> DeleteTableEntries()
        {
            var entries = await storage.ReadAllTableEntriesForPartitionAsync(GlobalServiceId).ConfigureAwait(false);

            var entriesList = new List <Tuple <GossipTableEntry, string> >(entries);

            if (entriesList.Count <= AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS)
            {
                await storage.DeleteTableEntriesAsync(entriesList).ConfigureAwait(false);
            }
            else
            {
                List <Task> tasks = new List <Task>();
                foreach (var batch in entriesList.BatchIEnumerable(AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS))
                {
                    tasks.Add(storage.DeleteTableEntriesAsync(batch));
                }
                await Task.WhenAll(tasks).ConfigureAwait(false);
            }
            return(entriesList.Count);
        }
 internal async Task<int> DeleteTableEntries()
 {
     var entries = await storage.ReadAllTableEntriesForPartitionAsync(GlobalServiceId).ConfigureAwait(false);
     var entriesList = new List<Tuple<GossipTableEntry, string>>(entries);
     if (entriesList.Count <= AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS)
     {
         await storage.DeleteTableEntriesAsync(entriesList).ConfigureAwait(false);
     }
     else
     {
         List<Task> tasks = new List<Task>();
         foreach (var batch in entriesList.BatchIEnumerable(AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS))
         {
             tasks.Add(storage.DeleteTableEntriesAsync(batch));
         }
         await Task.WhenAll(tasks).ConfigureAwait(false);
     }
     return entriesList.Count;
 }
        internal async Task<int> DeleteTableEntries(string deploymentId)
        {
            if (deploymentId == null) throw new ArgumentNullException("deploymentId");

            var entries = await storage.ReadAllTableEntriesForPartitionAsync(deploymentId);
            var entriesList = new List<Tuple<SiloInstanceTableEntry, string>>(entries);
            if (entriesList.Count <= AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS)
            {
                await storage.DeleteTableEntriesAsync(entriesList);
            }else
            {
                List<Task> tasks = new List<Task>();
                foreach (var batch in entriesList.BatchIEnumerable(AzureTableDefaultPolicies.MAX_BULK_UPDATE_ROWS))
                {
                    tasks.Add(storage.DeleteTableEntriesAsync(batch));
                }
                await Task.WhenAll(tasks);
            }
            return entriesList.Count();
        }