示例#1
0
        /// <summary>
        /// This method will delete rows for the table name specified corresponding to the filter criteria.  If no filter criteria is specified, all rows will be deleted.
        /// </summary>
        /// <param name="TableNameToDelete">Name of table from entries will be deleted.</param>
        /// <param name="TimeoutSeconds">Set timeout for table client.</param>
        /// <param name="filters">A list of Filter objects to be applied to table rows to delete.</param>
        /// <returns>A string indicating the result of the operation.</returns>
        public string DeleteAzureTableRows(string TableNameToDelete, int TimeoutSeconds = 30, List <Filter> filters = default(List <Filter>))
        {
            if (String.IsNullOrWhiteSpace(TableNameToDelete))
            {
                throw new ParameterSpecException("TableNameToDelete rows from is missing.");
            }

            if (!Filter.AreFiltersValid(filters))
            {
                throw new ParameterSpecException(String.Format("One or more of the supplied filter criteria is invalid."));
            }

            try
            {
                if (!CosmosTable.CloudStorageAccount.TryParse(new System.Net.NetworkCredential("", AzureTableConnectionSpec).Password, out CosmosTable.CloudStorageAccount StorageAccountSource))
                {
                    throw new ConnectionException("Can not connect to CloudStorage Account for Source Table.  Verify connection string.");
                }

                CosmosTable.CloudTableClient clientSource = CosmosTable.CloudStorageAccountExtensions.CreateCloudTableClient(StorageAccountSource, new CosmosTable.TableClientConfiguration());
                CosmosTable.CloudTable       TableSource  = clientSource.GetTableReference(TableNameToDelete);
                TableSource.ServiceClient.DefaultRequestOptions.ServerTimeout = new TimeSpan(0, 0, TimeoutSeconds);

                //CosmosTable.CloudTable TableDest = TableSource;

                bool   BatchWritten = true;
                string PartitionKey = String.Empty;
                CosmosTable.TableBatchOperation Batch = new CosmosTable.TableBatchOperation();
                int  BatchSize           = 100;
                int  BatchCount          = 0;
                long TotalRecordCountIn  = 0;
                long TotalRecordCountOut = 0;
                CosmosTable.TableContinuationToken token = null;

                do
                {
                    CosmosTable.TableQuery <CosmosTable.DynamicTableEntity> tq;
                    if (default(List <Filter>) == filters)
                    {
                        tq = new CosmosTable.TableQuery <CosmosTable.DynamicTableEntity>();
                    }
                    else
                    {
                        tq = new CosmosTable.TableQuery <CosmosTable.DynamicTableEntity>().Where(Filter.BuildFilterSpec(filters));
                    }
                    var queryResult = TableSource.ExecuteQuerySegmented(tq, token);

                    foreach (CosmosTable.DynamicTableEntity dte in queryResult.Results)
                    {
                        TotalRecordCountIn++;
                        if (String.Empty.Equals(PartitionKey))
                        {
                            PartitionKey = dte.PartitionKey;
                        }
                        if (dte.PartitionKey == PartitionKey)
                        {
                            Batch.Delete(dte);
                            //Batch.InsertOrReplace(dte);
                            BatchCount++;
                            TotalRecordCountOut++;
                            BatchWritten = false;
                        }
                        else
                        {
                            try
                            {
                                TableSource.ExecuteBatch(Batch);
                                Batch        = new CosmosTable.TableBatchOperation();
                                PartitionKey = dte.PartitionKey;
                                Batch.Delete(dte);
                                //Batch.InsertOrReplace(dte);
                                BatchCount = 1;
                                TotalRecordCountOut++;
                                BatchWritten = false;
                            }
                            catch (Exception ex)
                            {
                                throw new DeleteFailedException(String.Format("Table '{0}' row delete failed.", TableNameToDelete), ex);
                            }
                        }
                        if (BatchCount >= BatchSize)
                        {
                            try
                            {
                                TableSource.ExecuteBatch(Batch);
                                PartitionKey = String.Empty;
                                Batch        = new CosmosTable.TableBatchOperation();
                                BatchWritten = true;
                                BatchCount   = 0;
                            }
                            catch (Exception ex)
                            {
                                throw new DeleteFailedException(String.Format("Table '{0}' row deletion failed.", TableNameToDelete), ex);
                            }
                        }
                    }
                    token = queryResult.ContinuationToken;
                } while (token != null);

                if (!BatchWritten)
                {
                    try
                    {
                        TableSource.ExecuteBatch(Batch);
                        PartitionKey = String.Empty;
                    }
                    catch (Exception ex)
                    {
                        throw new DeleteFailedException(String.Format("Table '{0}' row deletion failed.", TableNameToDelete), ex);
                    }
                }
                return(String.Format("Table '{0}' total rows deleted {1}.", TableNameToDelete, TotalRecordCountIn));
            }
            catch (ConnectionException cex)
            {
                throw cex;
            }
            catch (Exception ex)
            {
                throw new DeleteFailedException(String.Format("Table '{0}' row deletion failed.", TableNameToDelete), ex);
            }
            finally
            {
            }
        }
示例#2
0
        /// <summary>
        /// Restore file created by BackupAzureTables to the destination table name specified.
        /// </summary>
        /// <param name="DestinationTableName">Name of the Azure Table to restore to -  may be different than name backed up originally.</param>
        /// <param name="InFilePathName">Complete file name and path containing the data to be restored.</param>
        /// <param name="TimeoutSeconds">Set timeout for table client.</param>
        /// <returns>A string indicating the table restored and record count.</returns>
        public string RestoreTableFromFile(string DestinationTableName, string InFilePathName, int TimeoutSeconds = 30)
        {
            if (String.IsNullOrWhiteSpace(DestinationTableName))
            {
                throw new ParameterSpecException("DestinationTableName is missing.");
            }

            if (Path.GetFullPath(InFilePathName) != InFilePathName)
            {
                throw new ParameterSpecException(String.Format("Invalid file name/path '{0}' specified.", InFilePathName));
            }
            else
            {
                if (!File.Exists(InFilePathName))
                {
                    throw new ParameterSpecException(String.Format("File '{0}' does not exist.", InFilePathName));
                }
            }

            TableSpec footer = null;

            try
            {
                if (!CosmosTable.CloudStorageAccount.TryParse(new System.Net.NetworkCredential("", AzureTableConnectionSpec).Password, out CosmosTable.CloudStorageAccount StorageAccount))
                {
                    throw new ConnectionException("Can not connect to CloudStorage Account.  Verify connection string.");
                }

                CosmosTable.CloudTableClient client    = CosmosTable.CloudStorageAccountExtensions.CreateCloudTableClient(StorageAccount, new CosmosTable.TableClientConfiguration());
                CosmosTable.CloudTable       TableDest = client.GetTableReference(DestinationTableName);
                TableDest.ServiceClient.DefaultRequestOptions.ServerTimeout = new TimeSpan(0, 0, TimeoutSeconds);
                TableDest.CreateIfNotExists();

                DynamicTableEntityJsonSerializer serializer = new DynamicTableEntityJsonSerializer();

                bool   BatchWritten = true;
                string PartitionKey = String.Empty;
                CosmosTable.TableBatchOperation Batch = new CosmosTable.TableBatchOperation();
                int  BatchSize        = 100;
                int  BatchCount       = 0;
                long TotalRecordCount = 0;

                using (StreamReader InputFileStream = new StreamReader(InFilePathName))
                {
                    string InFileLine = InputFileStream.ReadLine();
                    while (InFileLine != null)
                    {
                        if (InFileLine.Contains("ProcessingMetaData") && InFileLine.Contains("Header"))
                        {
                            System.Console.WriteLine(String.Format("Header {0}", InFileLine));
                        }
                        else if (InFileLine.Contains("ProcessingMetaData") && InFileLine.Contains("Footer"))
                        {
                            footer = JsonConvert.DeserializeObject <TableSpec>(InFileLine);
                            System.Console.WriteLine(String.Format("Footer {0}", InFileLine));
                        }
                        else
                        {
                            CosmosTable.DynamicTableEntity dte2 = serializer.Deserialize(InFileLine);
                            if (String.Empty.Equals(PartitionKey))
                            {
                                PartitionKey = dte2.PartitionKey;
                            }
                            if (dte2.PartitionKey == PartitionKey)
                            {
                                Batch.InsertOrReplace(dte2);
                                BatchCount++;
                                TotalRecordCount++;
                                BatchWritten = false;
                            }
                            else
                            {
                                try
                                {
                                    TableDest.ExecuteBatch(Batch);
                                    Batch        = new CosmosTable.TableBatchOperation();
                                    PartitionKey = dte2.PartitionKey;
                                    Batch.InsertOrReplace(dte2);
                                    BatchCount = 1;
                                    TotalRecordCount++;
                                    BatchWritten = false;
                                }
                                catch (Exception ex)
                                {
                                    throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
                                }
                            }
                            if (BatchCount >= BatchSize)
                            {
                                try
                                {
                                    TableDest.ExecuteBatch(Batch);
                                    PartitionKey = String.Empty;
                                    Batch        = new CosmosTable.TableBatchOperation();
                                    BatchWritten = true;
                                    BatchCount   = 0;
                                }
                                catch (Exception ex)
                                {
                                    throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
                                }
                            }
                        }
                        InFileLine = InputFileStream.ReadLine();
                    }  // while (InFileLine != null)

                    //final batch
                    if (!BatchWritten)
                    {
                        try
                        {
                            TableDest.ExecuteBatch(Batch);
                            PartitionKey = String.Empty;
                        }
                        catch (Exception ex) {
                            throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
                        }
                    }
                } // using (StreamReader

                if (null == footer)
                {
                    throw new RestoreFailedException(String.Format("Table '{0}' restore failed, no footer record found.", DestinationTableName));
                }
                else if (TotalRecordCount == footer.RecordCount)
                {
                    //OK, do nothing
                }
                else
                {
                    throw new RestoreFailedException(String.Format("Table '{0}' restore failed, records read {1} does not match expected count {2} in footer record.", DestinationTableName, TotalRecordCount, footer.RecordCount));
                }

                return(String.Format("Restore to table '{0}' Successful; {1} entries.", DestinationTableName, TotalRecordCount));
            }
            catch (ConnectionException cex)
            {
                throw cex;
            }
            catch (RestoreFailedException rex)
            {
                throw rex;
            }
            catch (Exception ex)
            {
                throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
            }
            finally
            {
            }
        }
示例#3
0
        } // RestoreTableFromBlobDirect

        private string RestoreFromStream(StreamReader InputFileStream, CosmosTable.CloudTable TableDest, string DestinationTableName)
        {
            bool   BatchWritten = true;
            string PartitionKey = String.Empty;

            CosmosTable.TableBatchOperation Batch = new CosmosTable.TableBatchOperation();
            int       BatchSize        = 100;
            int       BatchCount       = 0;
            long      TotalRecordCount = 0;
            TableSpec footer           = null;
            DynamicTableEntityJsonSerializer serializer = new DynamicTableEntityJsonSerializer();

            try
            {
                string InFileLine = InputFileStream.ReadLine();
                while (InFileLine != null)
                {
                    if (InFileLine.Contains("ProcessingMetaData") && InFileLine.Contains("Header"))
                    {
                        System.Console.WriteLine(String.Format("Header {0}", InFileLine));
                    }
                    else if (InFileLine.Contains("ProcessingMetaData") && InFileLine.Contains("Footer"))
                    {
                        footer = JsonConvert.DeserializeObject <TableSpec>(InFileLine);
                        System.Console.WriteLine(String.Format("Footer {0}", InFileLine));
                    }
                    else
                    {
                        CosmosTable.DynamicTableEntity dte2 = serializer.Deserialize(InFileLine);
                        if (String.Empty.Equals(PartitionKey))
                        {
                            PartitionKey = dte2.PartitionKey;
                        }
                        if (dte2.PartitionKey == PartitionKey)
                        {
                            Batch.InsertOrReplace(dte2);
                            BatchCount++;
                            TotalRecordCount++;
                            BatchWritten = false;
                        }
                        else
                        {
                            try
                            {
                                TableDest.ExecuteBatch(Batch);
                                Batch        = new CosmosTable.TableBatchOperation();
                                PartitionKey = dte2.PartitionKey;
                                Batch.InsertOrReplace(dte2);
                                BatchCount = 1;
                                TotalRecordCount++;
                                BatchWritten = false;
                            }
                            catch (Exception ex)
                            {
                                throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
                            }
                        }
                        if (BatchCount >= BatchSize)
                        {
                            try
                            {
                                TableDest.ExecuteBatch(Batch);
                                PartitionKey = String.Empty;
                                Batch        = new CosmosTable.TableBatchOperation();
                                BatchWritten = true;
                                BatchCount   = 0;
                            }
                            catch (Exception ex)
                            {
                                throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
                            }
                        }
                    }
                    InFileLine = InputFileStream.ReadLine();
                }  // while (InFileLine != null)

                //final batch
                if (!BatchWritten)
                {
                    try
                    {
                        TableDest.ExecuteBatch(Batch);
                        PartitionKey = String.Empty;
                    }
                    catch (Exception ex)
                    {
                        throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
                    }
                }

                if (null == footer)
                {
                    throw new RestoreFailedException(String.Format("Table '{0}' restore failed, no footer record found.", DestinationTableName));
                }
                else if (TotalRecordCount == footer.RecordCount)
                {
                    //OK, do nothing
                }
                else
                {
                    throw new RestoreFailedException(String.Format("Table '{0}' restore failed, records read {1} does not match expected count {2} in footer record.", DestinationTableName, TotalRecordCount, footer.RecordCount));
                }
            }
            catch (Exception ex)
            {
                throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
            }

            return(String.Format("Restore to table '{0}' Successful; {1} entries.", DestinationTableName, TotalRecordCount));
        }
示例#4
0
 public virtual Task <TableBatchResult> ExecuteBatchAsync(TableBatchOperation batch)
 {
     return(ExecuteBatchAsync(batch, CancellationToken.None));
 }
示例#5
0
 public virtual TableBatchResult ExecuteBatch(TableBatchOperation batch, TableRequestOptions requestOptions = null, OperationContext operationContext = null)
 {
     CommonUtility.AssertNotNull("batch", batch);
     return(batch.Execute(ServiceClient, this, requestOptions, operationContext));
 }
示例#6
0
 public virtual Task <TableBatchResult> ExecuteBatchAsync(TableBatchOperation batch, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
 {
     CommonUtility.AssertNotNull("batch", batch);
     return(batch.ExecuteAsync(ServiceClient, this, requestOptions, operationContext, cancellationToken));
 }
示例#7
0
 public virtual Task <TableBatchResult> ExecuteBatchAsync(TableBatchOperation batch, TableRequestOptions requestOptions, OperationContext operationContext)
 {
     return(ExecuteBatchAsync(batch, requestOptions, operationContext, CancellationToken.None));
 }
示例#8
0
 public virtual Task <TableBatchResult> ExecuteBatchAsync(TableBatchOperation batch, CancellationToken cancellationToken)
 {
     return(ExecuteBatchAsync(batch, null, null, cancellationToken));
 }