public async ValueTask <int> StageBatch(IReadOnlyList <TimeoutData> timeouts, int batchNumber)
        {
            await SqlTQueueCreator.TruncateTable(connection, SqlConstants.TimeoutMigrationStagingTable, schema, databaseName);

            foreach (var timeout in timeouts)
            {
                stagingDataTable.Rows.Add(DictionarySerializer.Serialize(timeout.Headers), timeout.State, timeout.Time);
            }

            await using var transaction = (SqlTransaction) await connection.BeginTransactionAsync();

            using var sqlBulk = new SqlBulkCopy(connection, SqlBulkCopyOptions.Default, transaction)
                  {
                      DestinationTableName = SqlConstants.TimeoutMigrationStagingTable,
                  };
            try
            {
                await sqlBulk.WriteToServerAsync(stagingDataTable);

                await transaction.CommitAsync();
            }
            catch (Exception e)
            {
                logger.LogError(e, $"Unable to bulk copy batch '{batchNumber}' to the staging table. Exception occured: {e.Message}");
                return(0);
            }
            finally
            {
                stagingDataTable.Clear();
            }

            return(timeouts.Count);
        }
 async ValueTask EnsureMigrationTableExists()
 {
     try
     {
         await SqlTQueueCreator.CreateStagingQueue(connection, SqlConstants.TimeoutMigrationStagingTable, schema, connection.Database, preview : false);
     }
     catch (Exception e)
     {
         logger.LogError($"Unable to create the staging queue '{SqlConstants.TimeoutMigrationStagingTable}'. The following exception occured: {e.Message}");
         throw;
     }
 }
        public async ValueTask <ITimeoutsTarget.IEndpointTargetBatchMigrator> PrepareTargetEndpointBatchMigrator(string endpointName)
        {
            await EnsureConnectionOpen();
            await EnsureMigrationTableExists();

            var endpointDelayedTableName = SqlConstants.DelayedTableName(endpointName);

            var actualEndpointDelayedTableName = await SqlTQueueCreator
                                                 .DoesDelayedDeliveryTableExist(connection, endpointDelayedTableName, schema, connection.Database)
                                                 .ConfigureAwait(false);

            return(new SqlTEndpointTarget(logger, connection, actualEndpointDelayedTableName, schema));
        }
        public async ValueTask <MigrationCheckResult> AbleToMigrate(EndpointInfo endpoint)
        {
            var migrationCheckResult = new MigrationCheckResult();

            try
            {
                await EnsureConnectionOpen();
            }
            catch (Exception e)
            {
                migrationCheckResult.Problems.Add($"Unable to connect to the server or database using the provided connection string. Verify the connection string. The following exception occured: {e.Message}");
                return(migrationCheckResult);
            }

            var databaseName = connection.Database;

            try
            {
                await SqlTQueueCreator.CreateStagingQueue(connection, SqlConstants.TimeoutMigrationStagingTable, schema, databaseName, preview : true);
            }
            catch (Exception e)
            {
                migrationCheckResult.Problems.Add($"Attempt to verify whether the timeout migration staging table '{SqlConstants.TimeoutMigrationStagingTable}' could be created during migration mode failed. The following exception occured: {e.Message}");
            }

            var endpointDelayedTableName = SqlConstants.DelayedTableName(endpoint.EndpointName);

            if (await SqlTQueueCreator
                .DoesDelayedDeliveryTableExist(connection, endpointDelayedTableName, schema, databaseName)
                .ConfigureAwait(false) == null)
            {
                migrationCheckResult.Problems.Add($"Could not find delayed queue table with name '{endpointDelayedTableName}' for the endpoint '{endpoint.EndpointName}'");
            }

            return(migrationCheckResult);
        }
 Task RemoveMigrationTable()
 {
     return(SqlTQueueCreator.DeleteStagingQueue(connection, SqlConstants.TimeoutMigrationStagingTable, schema, connection.Database));
 }
 public async ValueTask <int> CompleteBatch(int batchNumber)
 {
     return(await SqlTQueueCreator.MoveFromTo(connection, SqlConstants.TimeoutMigrationStagingTable, schema, endpointDelayedTableName, schema, databaseName));
 }