/// <summary>
/// Checks to see if messaging providers are configured.
/// </summary>
/// <returns></returns>
private async Task <bool> MessagingProvidersAreConfiguredAsync()
{
try
{
if (MessagingConnections != null && MessagingConnections.Count > 0)
{
// if we have already setup the connections, then we are configured.
return(true);
}
else
{
// otherwise check the database to see if we have any providers.
var messagingProviders = await Database.GetProvidersAsync(ProviderTypes.Messaging).ConfigureAwait(false);
if (messagingProviders.Count > 0)
{
// attemp to configure the providers.
var connections = new ProviderConnections(Database);
var messageProviderConnections = await connections.ConfigureMessagingProviderConnectionsAsync(Logger).ConfigureAwait(false);
if (messageProviderConnections != null)
{
MessagingConnections = messageProviderConnections;
return(true);
}
else
{
return(false);
}
}
else
{
// no providers setup yet.
Logger.WriteTraceMessage("No messaging providers have been configured yet. The status engine won't work until these have been configured.");
return(false);
}
}
}
catch (Exception ex)
{
Logger.WriteTraceError("Failed to lookup or configure messaging providers.", ex, Logger.GenerateFullContextStackTrace());
return(false);
}
}
/// <summary>
/// Checks to see if storage providers are configured.
/// </summary>
/// <returns></returns>
private async Task <bool> StorageProvidersAreConfiguredAsync()
{
try
{
if (Sender != null)
{
// if we have already setup the sender, we are configured.
return(true);
}
else
{
// otherwise check the database to see if we have any providers.
var storageProviders = await Database.GetProvidersAsync(ProviderTypes.Storage).ConfigureAwait(false);
if (storageProviders.Count > 0)
{
// attemp to configure the providers.
var connections = new ProviderConnections(Database);
var storageProviderConnections = await connections.ConfigureStorageProviderConnectionsAsync(Logger).ConfigureAwait(false);
if (storageProviderConnections != null)
{
Sender = new FileSender(Database, Logger, storageProviderConnections, InstanceID);
return(true);
}
else
{
return(false);
}
}
else
{
// no providers setup yet.
Logger.WriteTraceWarning("No storage providers have been configured yet. The backup engine(s) won't work until these have been configured.");
return(false);
}
}
}
catch (Exception ex)
{
Logger.WriteTraceError("Failed to lookup or configure storage providers.", ex, Logger.GenerateFullContextStackTrace());
return(false);
}
}
private async Task<BulkCopyRowsCopied> ProviderSpecificCopyInternal<T>(
ProviderConnections providerConnections,
ITable<T> table,
BulkCopyOptions options,
Func<List<Mapping.ColumnDescriptor>, BulkCopyReader<T>> createDataReader,
bool runAsync,
CancellationToken cancellationToken)
where T : notnull
{
var dataConnection = providerConnections.DataConnection;
var connection = providerConnections.ProviderConnection;
var transaction = providerConnections.ProviderTransaction;
var ed = dataConnection.MappingSchema.GetEntityDescriptor(typeof(T));
var columns = ed.Columns.Where(c => !c.SkipOnInsert || options.KeepIdentity == true && c.IsIdentity).ToList();
var rc = new BulkCopyRowsCopied();
var hanaOptions = SapHanaProviderAdapter.HanaBulkCopyOptions.Default;
if (options.KeepIdentity == true) hanaOptions |= SapHanaProviderAdapter.HanaBulkCopyOptions.KeepIdentity;
using (var bc = _provider.Adapter.CreateBulkCopy(connection, hanaOptions, transaction))
{
if (options.NotifyAfter != 0 && options.RowsCopiedCallback != null)
{
bc.NotifyAfter = options.NotifyAfter;
bc.HanaRowsCopied += (sender, args) =>
{
rc.RowsCopied = args.RowsCopied;
options.RowsCopiedCallback(rc);
if (rc.Abort)
args.Abort = true;
};
}
if (options.MaxBatchSize.HasValue)
bc.BatchSize = options.MaxBatchSize.Value;
if (options.BulkCopyTimeout.HasValue)
bc.BulkCopyTimeout = options.BulkCopyTimeout.Value;
else if (Common.Configuration.Data.BulkCopyUseConnectionCommandTimeout)
bc.BulkCopyTimeout = connection.ConnectionTimeout;
var sqlBuilder = dataConnection.DataProvider.CreateSqlBuilder(dataConnection.MappingSchema);
var tableName = GetTableName(sqlBuilder, options, table);
bc.DestinationTableName = tableName;
for (var i = 0; i < columns.Count; i++)
bc.ColumnMappings.Add(_provider.Adapter.CreateBulkCopyColumnMapping(i, columns[i].ColumnName));
var rd = createDataReader(columns);
await TraceActionAsync(
dataConnection,
() => (runAsync && bc.CanWriteToServerAsync ? "INSERT ASYNC BULK " : "INSERT BULK ") + tableName + Environment.NewLine,
async () => {
if (runAsync && bc.CanWriteToServerAsync)
await bc.WriteToServerAsync(rd, cancellationToken).ConfigureAwait(Common.Configuration.ContinueOnCapturedContext);
else
bc.WriteToServer(rd);
return rd.Count;
}).ConfigureAwait(Common.Configuration.ContinueOnCapturedContext);
if (rc.RowsCopied != rd.Count)
{
rc.RowsCopied = rd.Count;
if (options.NotifyAfter != 0 && options.RowsCopiedCallback != null)
options.RowsCopiedCallback(rc);
}
return rc;
}
}
private async Task <BulkCopyRowsCopied> ProviderSpecificCopyInternal <T>(
ProviderConnections providerConnections,
ITable <T> table,
BulkCopyOptions options,
Func <List <Mapping.ColumnDescriptor>, BulkCopyReader <T> > createDataReader,
bool runAsync,
CancellationToken cancellationToken)
where T : notnull
{
var dataConnection = providerConnections.DataConnection;
var connection = providerConnections.ProviderConnection;
var transaction = providerConnections.ProviderTransaction;
var ed = dataConnection.MappingSchema.GetEntityDescriptor(typeof(T));
var columns = ed.Columns.Where(c => !c.SkipOnInsert || options.KeepIdentity == true && c.IsIdentity).ToList();
var sb = _provider.CreateSqlBuilder(dataConnection.MappingSchema);
var rd = createDataReader(columns);
var sqlopt = SqlServerProviderAdapter.SqlBulkCopyOptions.Default;
var rc = new BulkCopyRowsCopied();
if (options.CheckConstraints == true)
{
sqlopt |= SqlServerProviderAdapter.SqlBulkCopyOptions.CheckConstraints;
}
if (options.KeepIdentity == true)
{
sqlopt |= SqlServerProviderAdapter.SqlBulkCopyOptions.KeepIdentity;
}
if (options.TableLock == true)
{
sqlopt |= SqlServerProviderAdapter.SqlBulkCopyOptions.TableLock;
}
if (options.KeepNulls == true)
{
sqlopt |= SqlServerProviderAdapter.SqlBulkCopyOptions.KeepNulls;
}
if (options.FireTriggers == true)
{
sqlopt |= SqlServerProviderAdapter.SqlBulkCopyOptions.FireTriggers;
}
if (options.UseInternalTransaction == true)
{
sqlopt |= SqlServerProviderAdapter.SqlBulkCopyOptions.UseInternalTransaction;
}
using (var bc = _provider.Adapter.CreateBulkCopy(connection, sqlopt, transaction))
{
if (options.NotifyAfter != 0 && options.RowsCopiedCallback != null)
{
bc.NotifyAfter = options.NotifyAfter;
bc.SqlRowsCopied += (sender, args) =>
{
rc.RowsCopied = args.RowsCopied;
options.RowsCopiedCallback(rc);
if (rc.Abort)
{
args.Abort = true;
}
};
}
if (options.MaxBatchSize.HasValue)
{
bc.BatchSize = options.MaxBatchSize.Value;
}
if (options.BulkCopyTimeout.HasValue)
{
bc.BulkCopyTimeout = options.BulkCopyTimeout.Value;
}
else if (Common.Configuration.Data.BulkCopyUseConnectionCommandTimeout)
{
bc.BulkCopyTimeout = connection.ConnectionTimeout;
}
var tableName = GetTableName(sb, options, table);
bc.DestinationTableName = tableName;
for (var i = 0; i < columns.Count; i++)
{
bc.ColumnMappings.Add(_provider.Adapter.CreateBulkCopyColumnMapping(i, sb.ConvertInline(columns[i].ColumnName, ConvertType.NameToQueryField)));
}
await TraceActionAsync(
dataConnection,
() => (runAsync ? "INSERT ASYNC BULK " : "INSERT BULK ") + tableName + "(" + string.Join(", ", columns.Select(x => x.ColumnName)) + ")" + Environment.NewLine,
async() => {
if (runAsync)
{
await bc.WriteToServerAsync(rd, cancellationToken).ConfigureAwait(Common.Configuration.ContinueOnCapturedContext);
}
else
{
bc.WriteToServer(rd);
}
return(rd.Count);
}, true).ConfigureAwait(Common.Configuration.ContinueOnCapturedContext);
}
if (rc.RowsCopied != rd.Count)
{
rc.RowsCopied = rd.Count;
if (options.NotifyAfter != 0 && options.RowsCopiedCallback != null)
{
options.RowsCopiedCallback(rc);
}
}
return(rc);
}
private async Task <BulkCopyRowsCopied> ProviderSpecificCopyInternal <T>(
ProviderConnections providerConnections,
ITable <T> table,
BulkCopyOptions options,
IAsyncEnumerable <T> source,
CancellationToken cancellationToken)
{
var dataConnection = providerConnections.DataConnection;
var connection = providerConnections.ProviderConnection;
var transaction = providerConnections.ProviderTransaction;
var ed = dataConnection.MappingSchema.GetEntityDescriptor(typeof(T));
var columns = ed.Columns.Where(c => !c.SkipOnInsert || options.KeepIdentity == true && c.IsIdentity).ToList();
var sb = _provider.CreateSqlBuilder(dataConnection.MappingSchema);
var rc = new BulkCopyRowsCopied();
var bc = _provider.Adapter.BulkCopy !.Create(connection, transaction);
if (options.NotifyAfter != 0 && options.RowsCopiedCallback != null)
{
bc.NotifyAfter = options.NotifyAfter;
bc.MySqlRowsCopied += (sender, args) =>
{
rc.RowsCopied += args.RowsCopied;
options.RowsCopiedCallback(rc);
if (rc.Abort)
{
args.Abort = true;
}
};
}
if (options.BulkCopyTimeout.HasValue)
{
bc.BulkCopyTimeout = options.BulkCopyTimeout.Value;
}
var tableName = GetTableName(sb, options, table);
bc.DestinationTableName = GetTableName(sb, options, table);
for (var i = 0; i < columns.Count; i++)
{
bc.AddColumnMapping(_provider.Adapter.BulkCopy.CreateColumnMapping(i, columns[i].ColumnName));
}
// emulate missing BatchSize property
// this is needed, because MySql fails on big batches, so users should be able to limit batch size
var batches = EnumerableHelper.Batch(source, options.MaxBatchSize ?? int.MaxValue);
await foreach (var batch in batches.WithCancellation(cancellationToken).ConfigureAwait(Common.Configuration.ContinueOnCapturedContext))
{
var rd = new BulkCopyReader <T>(dataConnection, columns, batch, cancellationToken);
await TraceActionAsync(
dataConnection,
() => "INSERT BULK " + tableName + "(" + string.Join(", ", columns.Select(x => x.ColumnName)) + Environment.NewLine,
async() => {
if (bc.CanWriteToServerAsync2)
{
await bc.WriteToServerAsync2(rd, cancellationToken).ConfigureAwait(Common.Configuration.ContinueOnCapturedContext);
}
else
if (bc.CanWriteToServerAsync)
{
await bc.WriteToServerAsync(rd, cancellationToken).ConfigureAwait(Common.Configuration.ContinueOnCapturedContext);
}
else
{
bc.WriteToServer(rd);
}
return(rd.Count);
}).ConfigureAwait(Common.Configuration.ContinueOnCapturedContext);
rc.RowsCopied += rd.Count;
}
if (options.NotifyAfter != 0 && options.RowsCopiedCallback != null)
{
options.RowsCopiedCallback(rc);
}
return(rc);
}
