public void IsValidDownloadDirectory_WhenDirectoryDoesNotExist_ReturnsFalse()
{
directoryServiceMock.Exists("DownloadDirectory").Returns(false);
bool actual = systemUnderTest.IsValidDownloadDirectory("DownloadDirectory");
Assert.That(actual, Is.False);
}
private void CreateTemporaryDirectory(string absPath)
{
var tmpDir = absPath + "\\tmp";
if (!_directoryService.Exists(tmpDir))
{
_directoryService.CreateDirectory(tmpDir);
}
}
public string GetDirectory(string relativeDirectoryName)
{
var fullPath = Path.Combine(_rootDirectory, relativeDirectoryName);
if (!_directoryService.Exists(fullPath))
{
_directoryService.Create(fullPath);
}
return(fullPath);
}
public Directory(string path, IDirectoryService directoryService, IFileService fileService)
{
if (directoryService == null)
{
throw new ArgumentNullException("directoryService");
}
_directoryService = directoryService;
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
if (!_directoryService.Exists(path))
{
throw new ArgumentException("path", "Directory does not exsit.");
}
if (fileService == null)
{
throw new ArgumentNullException("fileService");
}
Path = path;
_fileService = fileService;
}
private async void OnDeletemeMessageAsync(PackagingDeletemeMessage message)
{
if (message.Data.OperationType == PackageOperationType.Uninstall)
{
if (!_directoryService.Exists(message.Data.OperationPath))
{
return;
}
_fileSystemService.CreateDeleteme(message.Data.Package.Id, message.Data.OperationPath);
}
if (message.Data.OperationType == PackageOperationType.Install)
{
_fileSystemService.RemoveDeleteme(message.Data.Package.Id, message.Data.OperationPath);
//check is folder broken installation or not
//this handle cases where we perform installation of version, previously not correctly removed
if (await _nuGetPackageManager.IsPackageInstalledAsync(_defaultProject, message.Data.Package.GetIdentity(), default))
{
return;
}
_fileSystemService.CreateDeleteme(message.Data.Package.Id, message.Data.OperationPath);
}
}
public override async Task <IEnumerable <ISnapshot> > LoadSnapshotsAsync()
{
var directory = Directory;
Log.Debug($"Loading snapshots from '{directory}'");
var snapshots = new List <ISnapshot>();
if (_directoryService.Exists(directory))
{
foreach (var snapshotFile in _directoryService.GetFiles(directory, $"*{SnapshotExtension}"))
{
var snapshot = await LoadSnapshotAsync(snapshotFile);
if (snapshot != null)
{
snapshots.Add(snapshot);
}
}
}
Log.Debug($"Loaded '{snapshots.Count}' snapshots from '{directory}'");
return(snapshots);
}
public IDirectory CopyTo(string destBasePath)
{
if (string.IsNullOrWhiteSpace(destBasePath))
{
throw new ArgumentException("destBasePath cannot be null or white space.");
}
var destPath = destBasePath + _directoryService.DirectorySeparator + Name;
if (_directoryService.Exists(destPath))
{
throw new InvalidOperationException("Target directory " + destPath + " already exists.");
}
var destDir = _directoryService.CreateDirectory(destPath);
var files = _directoryService.GetFiles(this);
foreach (var filePath in files)
{
var sourceFile = _fileService.OpenFile(filePath);
var destFile = sourceFile.Copy(destDir.Path + _directoryService.DirectorySeparator + sourceFile.Name);
if (sourceFile.GetCheckSum() == destFile.GetCheckSum())
{
throw new InvalidOperationException("Source and destinatin file have different check sum.");
}
}
return(destDir);
}
public async Task IsAvailable_WhenInvoked_CheckForAccessToUploadDirectory(bool expected)
{
directoryServiceMock.Exists("C:\\Path").Returns(expected);
bool actual = await systemUnderTest.IsAvailable();
Assert.That(actual, Is.EqualTo(expected));
}
private bool DeleteDirectory(string fullName)
{
Argument.IsNotNullOrWhitespace(() => fullName);
Log.Debug($"Deleting directory '{fullName}'");
try
{
if (_directoryService.Exists(fullName))
{
_directoryService.Delete(fullName, true);
}
}
catch (Exception ex)
{
Log.Warning(ex, $"Failed to delete directory '{fullName}'");
}
return(!_directoryService.Exists(fullName));
}
private void PersistUserId(string userId)
{
var directoryName = Path.GetDirectoryName(UserIdFilePath);
if (!_directoryService.Exists(directoryName))
{
_directoryService.CreateDirectory(directoryName);
}
_fileService.WriteAllText(UserIdFilePath, userId);
}
/// <summary>
/// Method to invoke when the OpenInExplorer command is executed.
/// </summary>
private async Task OnOpenInExplorerExecuteAsync(string parameter)
{
if (!_directoryService.Exists(parameter))
{
await _messageService.ShowWarningAsync("The directory doesn't seem to exist. Cannot open the project in explorer.");
return;
}
_processService.StartProcess(parameter);
}
/// <summary>
/// Method to invoke when the OpenDirectory command is executed.
/// </summary>
private void OnOpenDirectoryExecute()
{
if (_directoryService.Exists(SelectedDirectory))
{
var fullPath = Path.GetFullPath(SelectedDirectory);
_processService.StartProcess(new ProcessContext
{
FileName = fullPath,
UseShellExecute = true
});
}
}
public ProjectFileService(IDirectoryService directoryService, [Inject(Key = "open")] IFileDialog openDialog, [Inject(Key = "save")] IFileDialog saveDialog, IProjectLoadSave loadSave, IDialogService dialogService)
{
_openFileDialog = openDialog;
_saveFileDialog = saveDialog;
_loadSave = loadSave;
_dialogService = dialogService;
ProjectDirectory = directoryService.GetCurrentDirectory() + "\\" + "Projects";
if (!directoryService.Exists(ProjectDirectory))
{
directoryService.CreateDirectory(ProjectDirectory);
}
}
/// <summary>
/// Removes Database backups older than 30 days. If all backups are older than 30 days, the latest is kept.
/// </summary>
public void CleanupBackups()
{
const int dayThreshold = 30;
_logger.LogInformation("Beginning cleanup of Database backups at {Time}", DateTime.Now);
var backupDirectory = Task.Run(() => _unitOfWork.SettingsRepository.GetSettingAsync(ServerSettingKey.BackupDirectory)).Result.Value;
if (!_directoryService.Exists(backupDirectory))
{
return;
}
var deltaTime = DateTime.Today.Subtract(TimeSpan.FromDays(dayThreshold));
var allBackups = _directoryService.GetFiles(backupDirectory).ToList();
var expiredBackups = allBackups.Select(filename => new FileInfo(filename))
.Where(f => f.CreationTime > deltaTime)
.ToList();
if (expiredBackups.Count == allBackups.Count)
{
_logger.LogInformation("All expired backups are older than {Threshold} days. Removing all but last backup", dayThreshold);
var toDelete = expiredBackups.OrderByDescending(f => f.CreationTime).ToList();
for (var i = 1; i < toDelete.Count; i++)
{
try
{
toDelete[i].Delete();
}
catch (Exception ex)
{
_logger.LogError(ex, "There was an issue deleting {FileName}", toDelete[i].Name);
}
}
}
else
{
foreach (var file in expiredBackups)
{
try
{
file.Delete();
}
catch (Exception ex)
{
_logger.LogError(ex, "There was an issue deleting {FileName}", file.Name);
}
}
}
_logger.LogInformation("Finished cleanup of Database backups at {Time}", DateTime.Now);
}
public PluginLoader(
Func <IProvideNodes> nodeProviderFactory,
Func <IDirectoryService> directoryServiceFactory)
{
_nodeProvider = nodeProviderFactory.Invoke();
_directoryService = directoryServiceFactory.Invoke();
_pluginDirectory = _directoryService.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\Plugins";
RegisterPluginNodesFromAssembly(Assembly.Load(nameof(DiiagramrAPI)), new NodeLibrary());
if (!_directoryService.Exists(_pluginDirectory))
{
_directoryService.CreateDirectory(_pluginDirectory);
}
LoadNonPluginDll();
GetInstalledPlugins();
}
public async Task <RepositoryDTO> GetParsedRepositoryAsync(string repositoryPath)
{
if (!directoryService.Exists(repositoryPath))
{
return(null);
}
RepositoryDTO repositoryDTO = new RepositoryDTO
{
Name = directoryService.GetName(repositoryPath),
Path = repositoryPath
};
await AddSolutionsToRepositoryAsync(repositoryDTO);
return(repositoryDTO);
}
public async Task <IResult <Unit, Error> > CopyDocAsync(string source, string destination)
{
var destinationDir = Path.GetDirectoryName(destination);
if (!_directoryService.Exists(destinationDir))
{
_directoryService.CreateDir(destinationDir);
}
return(await Result.Try(async() =>
{
await using var sourceStream = new FileStream(source, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 4096, FileOptions.Asynchronous | FileOptions.SequentialScan);
await using var destinationStream = new FileStream(destination, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: 4096, FileOptions.Asynchronous | FileOptions.SequentialScan);
await sourceStream.CopyToAsync(destinationStream);
},
ex => _logger.LogError(ex, $"Copy Failed! from {source} path to {destination} path")));
}
protected override void OnOperationStarting(object sender, PackageOperationEventArgs e)
{
var packagesConfig = Catel.IO.Path.Combine(Catel.IO.Path.GetParentDirectory(e.InstallPath), "packages.config");
if (e.PackageOperationType == PackageOperationType.Uninstall)
{
_backupFileSystemService.BackupFolder(e.InstallPath);
_backupFileSystemService.BackupFile(packagesConfig);
_rollbackPackageOperationService.PushRollbackAction(() =>
{
_backupFileSystemService.Restore(e.InstallPath);
_backupFileSystemService.Restore(packagesConfig);
}, CurrentContext);
}
if (e.PackageOperationType == PackageOperationType.Install)
{
_rollbackPackageOperationService.PushRollbackAction(() =>
{
bool success = true;
try
{
_directoryService.Delete(e.InstallPath);
success = !_directoryService.Exists(e.InstallPath);
}
catch (Exception)
{
success = false;
}
finally
{
if (!success)
{
_fileSystemService.CreateDeleteme(e.PackageDetails.Id, e.InstallPath);
Log.Error($"Failed to delete directory {e.InstallPath} during rollback actions.");
}
}
},
CurrentContext
);
}
}
public IKernel Load(IKernel kernel)
{
var executableLocation = _assemblyService.GetEntryAssembly().Location;
var additionalPluginsPath = _pathService.Combine(_pathService.GetDirectoryName(executableLocation), "Plugins");
if (!_directoryService.Exists(additionalPluginsPath))
{
_directoryService.CreateDirectory(additionalPluginsPath);
}
kernel.Bind(x => x
.FromAssembliesInPath(additionalPluginsPath)
.SelectAllClasses()
.InheritedFrom <IPlugin>()
.BindDefaultInterfaces()
.Configure(y => y.InTransientScope()));
return(kernel);
}
public Task SerializeDataAsync(string destFolder)
{
return(Task.Run(() =>
{
using (var db = dbFactory.Create())
{
foreach (var request in db.Requests)
{
var fileName = request.Date.ToString("yyyy-MM-dd") + ".xml";
if (!directory.Exists(destFolder))
{
directory.CreateDirectory(destFolder);
}
var fullPath = Path.Combine(destFolder, fileName);
if (file.Exists(fullPath))
{
file.Delete(fullPath);
}
using (var stream = file.Create(fullPath))
{
var xmlModel = new XmlRequestModel
{
Index = request.Index,
Content = new XmlRequestContentModel
{
Date = request.Date,
Name = request.Name,
Visits = request.Visits
}
};
var serializer = new XmlSerializer(typeof(XmlRequestModel));
serializer.Serialize(stream, xmlModel);
}
}
}
}));
}
public bool Copy(string source, string target)
{
if (_fileService.Exists(source))
{
var sourceFile = _fileService.OpenFile(source);
var targetFile = _fileService.Copy(sourceFile, target);
return(targetFile != null);
}
if (_directoryService.Exists(source))
{
var sourceDir = _directoryService.OpenDirectory(source);
var targetDir = sourceDir.CopyTo(target);
return(targetDir != null);
}
throw new ArgumentException("Unknown source.");
}
private void bindAdditionalPlugins()
{
_assemblyService = _kernel.Get <IAssemblyService>();
_directoryService = _kernel.Get <IDirectoryService>();
_pathService = _kernel.Get <IPathService>();
var executableLocation = _assemblyService.GetEntryAssembly().Location;
var additionalPluginsPath = _pathService.Combine(_pathService.GetDirectoryName(executableLocation), "Plugins");
if (!_directoryService.Exists(additionalPluginsPath))
{
_directoryService.CreateDirectory(additionalPluginsPath);
}
_kernel.Bind(x => x
.FromAssembliesInPath(additionalPluginsPath)
.SelectAllClasses()
.InheritedFrom <IPlugin>()
.BindDefaultInterfaces()
.Configure(y => y.InTransientScope()));
}
internal virtual string ResolveAndValidateCacheDirectory(bool cache, string cacheDirectory)
{
if (cache)
{
if (string.IsNullOrWhiteSpace(cacheDirectory))
{
return(Path.Combine(Directory.GetCurrentDirectory(), "ContentCache")); // Always valid
}
if (!_directoryService.Exists(cacheDirectory))
{
throw new OptionsException(nameof(IFlexiIncludeBlockOptions.CacheDirectory), string.Format(Strings.OptionsException_Shared_DirectoryDoesNotExist, cacheDirectory));
}
return(cacheDirectory);
}
else
{
return(null);
}
}
public Task <bool> IsAvailable()
{
string uploadDirectory = settings.UploadDirectory;
return(Task.FromResult(directoryService.Exists(uploadDirectory)));
}
public bool IsValidDownloadDirectory(string unsafeDownloadDirectory)
{
return(directoryService.Exists(unsafeDownloadDirectory));
}
///<inheritdoc/>
public void Init(string workspace)
{
string initDirectoryPath = Path.Combine(workspace, RESERVED_DIRECTORY_NAME.INIT);
if (!_directoryService.Exists(initDirectoryPath))
{
_directoryService.CreateDirectory(initDirectoryPath);
_fileService.AppendAllText(Path.Combine(initDirectoryPath, RESERVED_FILE_NAME.README), @$ "# The `{RESERVED_DIRECTORY_NAME.INIT}` directory
Initialization scripts. Executed once. This is called the first time you do `yuniql run`.");
_traceService.Info($"Created script directory {initDirectoryPath}");
}
string preDirectoryPath = Path.Combine(workspace, RESERVED_DIRECTORY_NAME.PRE);
if (!_directoryService.Exists(preDirectoryPath))
{
_directoryService.CreateDirectory(preDirectoryPath);
_fileService.AppendAllText(Path.Combine(preDirectoryPath, RESERVED_FILE_NAME.README), @$ "# The `{RESERVED_DIRECTORY_NAME.PRE}` directory
Pre migration scripts. Executed every time before any version.
");
_traceService.Info($"Created script directory {preDirectoryPath}");
}
string defaultVersionDirectoryPath = Path.Combine(workspace, RESERVED_DIRECTORY_NAME.BASELINE);
if (!_directoryService.Exists(defaultVersionDirectoryPath))
{
_directoryService.CreateDirectory(defaultVersionDirectoryPath);
_fileService.AppendAllText(Path.Combine(defaultVersionDirectoryPath, RESERVED_FILE_NAME.README), @"# The `v0.00` directory
Baseline scripts. Executed once. This is called when you do `yuniql run`.");
_traceService.Info($"Created script directory {defaultVersionDirectoryPath}");
}
string draftDirectoryPath = Path.Combine(workspace, RESERVED_DIRECTORY_NAME.DRAFT);
if (!_directoryService.Exists(draftDirectoryPath))
{
_directoryService.CreateDirectory(draftDirectoryPath);
_fileService.AppendAllText(Path.Combine(draftDirectoryPath, RESERVED_FILE_NAME.README), $@"# The `{RESERVED_DIRECTORY_NAME.DRAFT}` directory
Scripts in progress. Scripts that you are currently working and have not moved to specific version directory yet. Executed every time after the latest version.");
_traceService.Info($"Created script directory {draftDirectoryPath}");
}
string postDirectoryPath = Path.Combine(workspace, RESERVED_DIRECTORY_NAME.POST);
if (!_directoryService.Exists(postDirectoryPath))
{
_directoryService.CreateDirectory(postDirectoryPath);
_fileService.AppendAllText(Path.Combine(postDirectoryPath, RESERVED_FILE_NAME.README), $@"# The `{RESERVED_DIRECTORY_NAME.POST}` directory
Post migration scripts. Executed every time and always the last batch to run.");
_traceService.Info($"Created script directory {postDirectoryPath}");
}
string eraseDirectoryPath = Path.Combine(workspace, RESERVED_DIRECTORY_NAME.ERASE);
if (!_directoryService.Exists(eraseDirectoryPath))
{
_directoryService.CreateDirectory(eraseDirectoryPath);
_fileService.AppendAllText(Path.Combine(eraseDirectoryPath, RESERVED_FILE_NAME.README), $@"# The `{RESERVED_DIRECTORY_NAME.ERASE}` directory
Database cleanup scripts. Executed once only when you do `yuniql erase`.");
_traceService.Info($"Created script directory {eraseDirectoryPath}");
}
var readMeFile = Path.Combine(workspace, RESERVED_FILE_NAME.README);
if (!_fileService.Exists(readMeFile))
{
var assembly = typeof(WorkspaceService).Assembly;
var embededReadMeFile = $"{assembly.GetName().Name}.TemplateReadMe.md";
_fileService.AppendAllText(readMeFile, _fileService.ReadAllEmbeddedText(embededReadMeFile));
_traceService.Info($"Created file {readMeFile}");
}
var dockerFile = Path.Combine(workspace, RESERVED_FILE_NAME.DOCKER_FILE);
if (!_fileService.Exists(dockerFile))
{
_fileService.AppendAllText(dockerFile, @"FROM yuniql/yuniql:latest
COPY . ./db
");
_traceService.Info($"Created file {dockerFile}");
}
var gitIgnoreFile = Path.Combine(workspace, RESERVED_FILE_NAME.GIT_IGNORE_FILE);
if (!_fileService.Exists(gitIgnoreFile))
{
_fileService.AppendAllText(gitIgnoreFile, @"
.plugins
yuniql.exe
yuniql.pdb
yuniqlx.exe
yuniql-log-*.txt
");
_traceService.Info($"Created file {gitIgnoreFile}");
}
}
/// <inheritdoc />
public void RunVersionDirectories(
IDbConnection connection,
IDbTransaction transaction,
List <string> appliedVersions,
string workspace,
string targetVersion,
TransactionContext transactionContext,
List <KeyValuePair <string, string> > tokens = null,
string bulkSeparator = null,
string metaSchemaName = null,
string metaTableName = null,
int?commandTimeout = null,
int?bulkBatchSize = null,
string appliedByTool = null,
string appliedByToolVersion = null,
string environment = null,
string transactionMode = null
)
{
//excludes all versions already executed
var versionDirectories = _directoryService.GetDirectories(workspace, "v*.*")
.Where(v => !appliedVersions.Contains(new DirectoryInfo(v).Name))
.ToList();
//exclude all versions greater than the target version
if (!string.IsNullOrEmpty(targetVersion))
{
versionDirectories.RemoveAll(v =>
{
var cv = new LocalVersion(new DirectoryInfo(v).Name);
var tv = new LocalVersion(targetVersion);
return(string.Compare(cv.SemVersion, tv.SemVersion) == 1);
});
}
//execute all sql scripts in the version folders
if (versionDirectories.Any())
{
versionDirectories.Sort();
versionDirectories.ForEach(versionDirectory =>
{
//initialize stop watch to measure duration of execution per version
var stopwatch = new Stopwatch();
stopwatch.Start();
if (!string.IsNullOrEmpty(transactionMode) && transactionMode.Equals(TRANSACTION_MODE.VERSION))
{
using (var internalConnection = _dataService.CreateConnection())
{
internalConnection.Open();
using (var internalTransaction = internalConnection.BeginTransaction())
{
try
{
if (null != internalTransaction)
{
_traceService.Info("Transaction created for current version. This version migration run will be executed in this dedicated connection and transaction context.");
}
//run scripts in all sub-directories in the version
var scriptSubDirectories = _directoryService.GetAllDirectories(versionDirectory, "*").ToList();;
RunVersionDirectoriesInternal(internalConnection, internalTransaction, scriptSubDirectories, versionDirectory, versionDirectory, stopwatch);
internalTransaction.Commit();
}
catch (Exception)
{
internalTransaction.Rollback();
throw;
}
}
}
}
else
{
//collect all child directions in current version vxx.xx
var scriptSubDirectories = _directoryService.GetAllDirectories(versionDirectory, "*").ToList();;
//check for special _transaction directory in the version vxx.xx directory
var transactionDirectory = Path.Combine(versionDirectory, RESERVED_DIRECTORY_NAME.TRANSACTION);
var transactionExplicit = _directoryService.Exists(transactionDirectory);
if (transactionExplicit)
{
//check version directory with _transaction directory only applies to platforms NOT supporting transactional ddl
if (_dataService.IsTransactionalDdlSupported)
{
throw new YuniqlMigrationException(@$ "The version directory " "{versionDirectory}" " can't contain " "{RESERVED_DIRECTORY_NAME.TRANSACTION}" " subdirectory for selected target platform, because the whole migration is already running in single transaction.");
}
//check version directory must only contain _transaction directory and nothing else
if (_directoryService.GetDirectories(versionDirectory, "*").Count() > 1)
{
throw new YuniqlMigrationException(@$ "The version directory " "{versionDirectory}" " containing " "{RESERVED_DIRECTORY_NAME.TRANSACTION}" " subdirectory can't contain other subdirectories.");
}
//check version directory must only contain _transaction directory, files are also not allowed
//check users need to place the script files and subdirectories inside _transaction directory
if (_directoryService.GetFiles(versionDirectory, "*.*").Count() > 0)
{
throw new YuniqlMigrationException(@$ "The version directory " "{versionDirectory}" " containing " "{RESERVED_DIRECTORY_NAME.TRANSACTION}" " subdirectory can't contain files.");
}
//override the list of subdirectories to process by the directory list container in _transaction directory
scriptSubDirectories = _directoryService.GetAllDirectories(transactionDirectory, "*").ToList();
}
if (transactionExplicit)
{
//run scripts within a single transaction for all scripts inside _transaction directory and scripts in the child directories
string versionName = new DirectoryInfo(versionDirectory).Name;
_traceService.Warn(@$ "The " "{RESERVED_DIRECTORY_NAME.TRANSACTION}" " directory has been detected and therefore " "{versionName}" " version scripts will run in single transaction. The rollback will not be reliable in case the version scripts contain commands causing implicit commit (e.g. DDL)!");
using (var transaction = connection.BeginTransaction())
{
try
{
//scriptSubDirectories is the child directories under _transaction directory c:\temp\vxx.xx\_transaction\list_of_directories
//transactionDirectory the path of _transaction directory c:\temp\vxx.xx\_transaction
//versionDirectory path of version c:\temp\vxx.xx
RunVersionDirectoriesInternal(connection, transaction, scriptSubDirectories, transactionDirectory, versionDirectory, stopwatch);
transaction.Commit();
_traceService.Info(@$ "Target database has been commited after running " "{versionName}" " version scripts.");
}
catch (Exception)
{
_traceService.Error(@$ "Target database will be rolled back to the state before running " "{versionName}" " version scripts.");
transaction.Rollback();
throw;
}
}
}
else
{
if (null == transaction)
{
_traceService.Warn("Transaction is disabled for current session. This version migration run will be executed without explicit transaction context.");
}
//run scripts without transaction
//scriptSubDirectories is the child directories under _transaction directory c:\temp\vxx.xx\list_of_directories
//versionDirectory path of version c:\temp\vxx.xx
RunVersionDirectoriesInternal(connection, transaction, scriptSubDirectories, versionDirectory, versionDirectory, stopwatch);
}
}
//reset duration timer
stopwatch.Restart();
});
}
else
{
var connectionInfo = _dataService.GetConnectionInfo();
_traceService.Info($"Target database is updated. No migration step executed at {connectionInfo.Database} on {connectionInfo.DataSource}.");
}
void RunVersionDirectoriesInternal(IDbConnection connection, IDbTransaction transaction, List <string> scriptSubDirectories, string scriptDirectory, string versionDirectory, Stopwatch stopwatch)
{
try
{
var versionName = new DirectoryInfo(versionDirectory).Name;
scriptSubDirectories.Sort();
scriptSubDirectories.ForEach(scriptSubDirectory =>
{
//run all scripts in the current version folder
RunVersionSqlScripts(connection, transaction, transactionContext, stopwatch, versionName, workspace, scriptSubDirectory, metaSchemaName, metaTableName, tokens, commandTimeout, environment, appliedByTool, appliedByToolVersion);
//import csv files into tables of the the same filename as the csv
RunBulkImportScripts(connection, transaction, workspace, scriptSubDirectory, bulkSeparator, bulkBatchSize, commandTimeout, environment);
});
//run all scripts in the current version folder
RunVersionSqlScripts(connection, transaction, transactionContext, stopwatch, versionName, workspace, scriptDirectory, metaSchemaName, metaTableName, tokens, commandTimeout, environment);
//import csv files into tables of the the same filename as the csv
RunBulkImportScripts(connection, transaction, workspace, scriptDirectory, bulkSeparator, bulkBatchSize, commandTimeout, environment);
//update db version
stopwatch.Stop();
_metadataService.InsertVersion(connection, transaction, versionName, transactionContext,
metaSchemaName: metaSchemaName,
metaTableName: metaTableName,
commandTimeout: commandTimeout,
appliedByTool: appliedByTool,
appliedByToolVersion: appliedByToolVersion,
durationMs: Convert.ToInt32(stopwatch.ElapsedMilliseconds));
_traceService.Info($"Completed migration to version {versionDirectory} in {Convert.ToInt32(stopwatch.ElapsedMilliseconds)} ms");
}
finally
{
//clear nontransactional context to ensure it is not applied on next version
transactionContext = null;
}
}
}
public async Task <bool> RunAsync()
{
var folderProject = new FolderNuGetProject(_defaultProject.ContentPath);
if (!_directoryService.Exists(_defaultProject.ContentPath))
{
Log.Info($"Plugins folder does not exist");
return(false);
}
var subFolders = folderProject.GetPackageDirectories();
var failedIdentities = new List <PackageIdentity>();
var parsedPackages = new List <IPackageDetails>();
bool anyUpgraded = false;
using (var context = AcquireSourceContextForActions())
{
if (context == SourceContext.EmptyContext)
{
Log.Warning($"Source context is empty");
return(false);
}
foreach (var folder in subFolders)
{
var packageFolderName = Path.GetFileName(folder);
var package = PackageIdentityParser.Parse(packageFolderName);
var packageDetails = PackageDetailsFactory.Create(package);
parsedPackages.Add(packageDetails);
}
//no valid package folders
if (!parsedPackages.Any())
{
return(false);
}
_packageOperationNotificationService.NotifyAutomaticOperationBatchStarting(PackageOperationType.Install, parsedPackages.ToArray());
foreach (var packageDetails in parsedPackages)
{
var package = packageDetails.GetIdentity();
if (package is null)
{
continue;
}
var installationPath = _defaultProject.GetInstallPath(package);
var isV2packageInstalled = folderProject.PackageExists(package, NuGet.Packaging.PackageSaveMode.Defaultv2);
if (!isV2packageInstalled)
{
Log.Warning($"Package '{package}' is recognized in project folder as v2 NuGet installed package");
continue;
}
if (await _nuGetPackageManager.IsPackageInstalledAsync(_defaultProject, package, default))
{
Log.Info($"Skipping package '{package}', package is valid");
continue;
}
_packageOperationNotificationService.NotifyAutomaticOperationStarting(installationPath, PackageOperationType.Install, packageDetails);
//reinstall
try
{
var isInstalled = await _nuGetPackageManager.InstallPackageForProjectAsync(_defaultProject, package, default, false);
private void RunVersionScripts(
IDbConnection connection,
IDbTransaction transaction,
List <string> dbVersions,
string workingPath,
string targetVersion,
NonTransactionalContext nonTransactionalContext,
List <KeyValuePair <string, string> > tokenKeyPairs = null,
string delimiter = null,
string schemaName = null,
string tableName = null,
int?commandTimeout = null,
int?batchSize = null,
string appliedByTool = null,
string appliedByToolVersion = null,
string environmentCode = null
)
{
//excludes all versions already executed
var versionDirectories = _directoryService.GetDirectories(workingPath, "v*.*")
.Where(v => !dbVersions.Contains(new DirectoryInfo(v).Name))
.ToList();
//exclude all versions greater than the target version
if (!string.IsNullOrEmpty(targetVersion))
{
versionDirectories.RemoveAll(v =>
{
var cv = new LocalVersion(new DirectoryInfo(v).Name);
var tv = new LocalVersion(targetVersion);
return(string.Compare(cv.SemVersion, tv.SemVersion) == 1);
});
}
//execute all sql scripts in the version folders
if (versionDirectories.Any())
{
versionDirectories.Sort();
versionDirectories.ForEach(versionDirectory =>
{
try
{
//run scripts in all sub-directories
List <string> scriptSubDirectories = null;
//check for transaction directory
bool isExplicitTransactionDefined = false;
string transactionDirectory = Path.Combine(versionDirectory, "_transaction");
if (_directoryService.Exists(transactionDirectory))
{
if (_dataService.IsAtomicDDLSupported)
{
throw new YuniqlMigrationException(@$ "The version directory " "{versionDirectory}" " can't contain " "_transaction" " subdirectory for selected target platform, because the whole migration is already running in single transaction.");
}
if (_directoryService.GetDirectories(versionDirectory, "*").Count() > 1)
{
throw new YuniqlMigrationException(@$ "The version directory " "{versionDirectory}" " containing " "_transaction" " subdirectory can't contain other subdirectories");
}
else if (_directoryService.GetFiles(versionDirectory, "*.*").Count() > 0)
{
throw new YuniqlMigrationException(@$ "The version directory " "{versionDirectory}" " containing " "_transaction" " subdirectory can't contain files");
}
isExplicitTransactionDefined = true;
scriptSubDirectories = _directoryService.GetAllDirectories(transactionDirectory, "*").ToList();
}
else
{
scriptSubDirectories = _directoryService.GetAllDirectories(versionDirectory, "*").ToList();
}
if (isExplicitTransactionDefined)
{
string versionName = new DirectoryInfo(versionDirectory).Name;
//run scripts within a single transaction
_traceService.Info(@$ "The " "_transaction" " directory has been detected and therefore " "{versionName}" " version scripts will run in single transaction. The rollback will not be reliable in case the version scripts contain commands causing implicit commit (e.g. DDL)!");
using (var transaction = connection.BeginTransaction())
{
try
{
RunVersionScriptsInternal(transaction, scriptSubDirectories, transactionDirectory, versionDirectory, schemaName, tableName);
transaction.Commit();
_traceService.Info(@$ "Target database has been commited after running " "{versionName}" " version scripts.");
}
catch (Exception)
{
_traceService.Error(@$ "Target database will be rolled back to the state before running " "{versionName}" " version scripts.");
transaction.Rollback();
throw;
}
}
}
else //run scripts without transaction
{
RunVersionScriptsInternal(transaction, scriptSubDirectories, versionDirectory, versionDirectory, schemaName, tableName);
}
}
catch (Exception)
{
throw;
}
});
}
else
{
var connectionInfo = _dataService.GetConnectionInfo();
_traceService.Info($"Target database is updated. No migration step executed at {connectionInfo.Database} on {connectionInfo.DataSource}.");
}
void RunVersionScriptsInternal(IDbTransaction transaction, List <string> scriptSubDirectories, string scriptDirectory, string versionDirectory, string schemaName, string tableName)
{
try
{
string versionName = new DirectoryInfo(versionDirectory).Name;
scriptSubDirectories.Sort();
scriptSubDirectories.ForEach(scriptSubDirectory =>
{
//run all scripts in the current version folder
RunSqlScripts(connection, transaction, nonTransactionalContext, versionName, workingPath, scriptSubDirectory, schemaName, tableName, tokenKeyPairs, commandTimeout, environmentCode, appliedByTool, appliedByToolVersion);
//import csv files into tables of the the same filename as the csv
RunBulkImport(connection, transaction, workingPath, scriptSubDirectory, delimiter, batchSize, commandTimeout, environmentCode);
});
//run all scripts in the current version folder
RunSqlScripts(connection, transaction, nonTransactionalContext, versionName, workingPath, scriptDirectory, schemaName, tableName, tokenKeyPairs, commandTimeout, environmentCode, appliedByTool, appliedByToolVersion);
//import csv files into tables of the the same filename as the csv
RunBulkImport(connection, transaction, workingPath, scriptDirectory, delimiter, batchSize, commandTimeout, environmentCode);
//update db version
_configurationDataService.InsertVersion(connection, transaction, versionName,
schemaName: schemaName,
tableName: tableName,
commandTimeout: commandTimeout,
appliedByTool: appliedByTool,
appliedByToolVersion: appliedByToolVersion);
_traceService.Info($"Completed migration to version {versionDirectory}");
}
finally
{
//Clear nontransactional context to ensure it is not applied on next version
nonTransactionalContext = null;
}
}
}
