private bool IsMetdataMemberExtracted(SqlWorkerTask task)
{
return((task & (
SqlWorkerTask.ExtractMetadataTypes |
SqlWorkerTask.ExtractMetadataAssemblies |
SqlWorkerTask.ExtractMetadataExtension)) > 0);
}
private void ValidateSchema(SqlWorkerTask task, SqlWorkerResult result)
{
var error = string.Format(ErrorMessage, task);
if (!task.HasFlag(SqlWorkerTask.ExtractSchema))
{
Assert.IsNull(result.Schema, error);
}
else
{
Assert.IsNotNull(result.Schema, error);
Assert.IsNotEmpty(result.Schema.Catalogs, error);
}
}
private void ValidateWorkerResult(SqlWorkerTask task)
{
var result = SqlWorker.Create(accessor, task).Invoke();
var error = string.Format(ErrorMessage, task);
ValidateSchema(task, result);
if (task == SqlWorkerTask.DropSchema)
{
Assert.IsTrue(result.Schema == null, error);
Assert.IsTrue(result.Metadata == null, error);
return;
}
ValidateMetadata(task, result, task.HasFlag(SqlWorkerTask.DropSchema));
}
private void ValidateMetadata(SqlWorkerTask task, SqlWorkerResult result, bool isSchemaDropped)
{
var error = string.Format(ErrorMessage, task);
if (!IsMetdataMemberExtracted(task))
{
Assert.IsNull(result.Metadata);
}
else
{
Assert.That(result.Metadata.Types.Any(), Is.EqualTo(!isSchemaDropped && task.HasFlag(SqlWorkerTask.ExtractMetadataTypes)), error);
Assert.That(result.Metadata.Assemblies.Any(), Is.EqualTo(!isSchemaDropped && task.HasFlag(SqlWorkerTask.ExtractMetadataAssemblies)), error);
Assert.That(result.Metadata.Extensions.Any(), Is.EqualTo(!isSchemaDropped && task.HasFlag(SqlWorkerTask.ExtractMetadataExtension)), error);
}
}
private async Task ValidateWorkerResultAsync(SqlWorkerTask task)
{
var result = await SqlAsyncWorker.Create(accessor, task, CancellationToken.None).Invoke();
var error = string.Format(ErrorMessage, task);
ValidateSchema(task, result);
if (task == SqlWorkerTask.DropSchema)
{
Assert.IsTrue(result.Schema == null, error);
Assert.IsTrue(result.Metadata == null, error);
}
else
{
ValidateMetadata(task, result, task.HasFlag(SqlWorkerTask.DropSchema));
}
}
private static SqlWorkerResult Run(UpgradeServiceAccessor services, SqlWorkerTask task)
{
var result = new SqlWorkerResult();
var executor = new SqlExecutor(services.StorageDriver, services.Connection);
if ((task & SqlWorkerTask.DropSchema) > 0)
{
DropSchema(services, executor);
}
if ((task & SqlWorkerTask.ExtractSchema) > 0)
{
result.Schema = ExtractSchema(services, executor);
}
if ((task & (SqlWorkerTask.ExtractMetadataTypes | SqlWorkerTask.ExtractMetadataAssemblies | SqlWorkerTask.ExtractMetadataExtension)) > 0)
{
ExtractMetadata(services, executor, result, task);
}
return(result);
}
private static async Task <SqlWorkerResult> RunAsync(
UpgradeServiceAccessor services, SqlWorkerTask task, CancellationToken token)
{
var result = new SqlWorkerResult();
var executor = new SqlExecutor(services.StorageDriver, services.Connection);
if ((task & SqlWorkerTask.DropSchema) > 0)
{
await DropSchemaAsync(services, executor, token).ConfigureAwait(false);
}
if ((task & SqlWorkerTask.ExtractSchema) > 0)
{
result.Schema = await ExtractSchemaAsync(services, executor, token).ConfigureAwait(false);
}
if ((task & (SqlWorkerTask.ExtractMetadataTypes | SqlWorkerTask.ExtractMetadataAssemblies | SqlWorkerTask.ExtractMetadataExtension)) > 0)
{
await ExtractMetadataAsync(services, executor, result, task, token).ConfigureAwait(false);
}
return(result);
}
private static async Task ExtractMetadataAsync(
UpgradeServiceAccessor services, SqlExecutor executor, SqlWorkerResult result, SqlWorkerTask task,
CancellationToken token)
{
var set = new MetadataSet();
var mapping = new MetadataMapping(services.StorageDriver, services.NameBuilder);
var metadataExtractor = new MetadataExtractor(mapping, executor);
foreach (var metadataTask in services.MappingResolver.GetMetadataTasks()
.Where(metadataTask => !ShouldSkipMetadataExtraction(mapping, result, metadataTask)))
{
try {
if (task.HasFlag(SqlWorkerTask.ExtractMetadataAssemblies))
{
await metadataExtractor.ExtractAssembliesAsync(set, metadataTask, token).ConfigureAwait(false);
}
if (task.HasFlag(SqlWorkerTask.ExtractMetadataTypes))
{
await metadataExtractor.ExtractTypesAsync(set, metadataTask, token).ConfigureAwait(false);
}
if (task.HasFlag(SqlWorkerTask.ExtractMetadataExtension))
{
await metadataExtractor.ExtractExtensionsAsync(set, metadataTask, token).ConfigureAwait(false);
}
}
catch (Exception exception) {
UpgradeLog.Warning(
Strings.LogFailedToExtractMetadataFromXYZ, metadataTask.Catalog, metadataTask.Schema, exception);
}
}
result.Metadata = set;
}
public static Func <Task <SqlWorkerResult> > Create(
UpgradeServiceAccessor services, SqlWorkerTask task, CancellationToken token) =>
() => RunAsync(services, task, token);
public static Func <SqlWorkerResult> Create(UpgradeServiceAccessor services, SqlWorkerTask task)
{
return(() => Run(services, task));
}
