/// <summary> /// Execute the command with the specified arguments. /// </summary> /// <param name='args'> /// The arguments. /// </param> /// <param name="arguments"> /// The parsed arguments. /// </param> /// <param name="archive"> /// The database archive containing the versions. /// </param> /// <returns>Returns the result of Executing the Command</returns> protected override bool Execute(string[] args, CreateArguments arguments, IDatabaseArchive archive) { if (string.IsNullOrEmpty(arguments.Archive)) { this.MessageService.WriteLine("Please specify an archive using the -a switch"); return(false); } if (archive == null) { this.MessageService.WriteLine("The specified archive is not supported"); return(false); } try { return(this.Creator.Create(archive, arguments.Version, CreateTaskExecuter(arguments), !arguments.ShouldRollbackChanges && !arguments.IsSimulatingUpdate, arguments.ShouldExecuteMissingTasks)); } catch (VersionNotFoundException v) { this.MessageService.WriteLine(v.Message); } catch (TaskExecutionException t) { this.MessageService.WriteLine(t.Message); } return(false); }
protected override bool Execute(string[] args, CreateArguments arguments, IDatabaseArchive archive) { if (archive == null) { this.MessageService.WriteLine("Please specify an archive using the -a switch."); return(false); } return(this.CheckDatabase(arguments, archive)); }
private void AddTasksToExecuter(IDatabaseArchive archive, ITaskExecuter executer, VersionBase currentVersion, VersionBase targetVersion, bool executeMissingTasks, ISession session, bool targetVersionSpecified) { if (executeMissingTasks) { this.AddAllTasks(archive, executer, targetVersion, session, targetVersionSpecified); } else { this.AddNewTasks(archive, executer, currentVersion, targetVersion, session); } }
private void AddAllTasks(IDatabaseArchive archive, ITaskExecuter executer, VersionBase targetVersion, ISession session, bool targetVersionSpecified) { // If we're executing missing tasks, we need to go through each version and check whether any tasks are missing // In this case, if the target version is specified, we only look in that version var versions = archive.Versions.OrderBy(v => v.Version, this.VersionProvider.GetComparer()) .Where( v => !targetVersionSpecified || this.VersionProvider.GetComparer().Compare(targetVersion, v.Version) == 0); this.AddTasksForVersions(executer, versions, session); }
public void ShouldCreateAFileDatabaseArchive() { // Arrange FileDatabaseArchiveFactory factory = new FileDatabaseArchiveFactory(); DirectoryInfo testDirectory = FileUtil.CreateTempDirectory(); // Act IDatabaseArchive archive = factory.Create(testDirectory.FullName); // Assert Assert.IsType <FileDatabaseArchive>(archive); }
public void ShouldCreateArchiveWithTheSpecifiedPath() { // Arrange FileDatabaseArchiveFactory factory = new FileDatabaseArchiveFactory(); DirectoryInfo testDirectory = FileUtil.CreateTempDirectory(); // Act IDatabaseArchive archive = factory.Create(testDirectory.FullName); // Assert Assert.Equal(testDirectory.FullName, archive.ArchivePath); testDirectory.Delete(); }
private void AddNewTasks(IDatabaseArchive archive, ITaskExecuter executer, VersionBase currentVersion, VersionBase targetVersion, ISession session) { IEnumerable <IDatabaseVersion> versionsToExecute = archive.Versions .OrderBy(v => v.Version, this.VersionProvider.GetComparer()) .Where( v => currentVersion == null || this.VersionProvider.GetComparer() .Compare(currentVersion, v.Version) <= 0) .TakeWhile( v => this.VersionProvider.GetComparer() .Compare(targetVersion, v.Version) >= 0); this.AddTasksForVersions(executer, versionsToExecute, session); }
public void ShouldCreateAnArchiveWithTheCorrectArchivePath() { // Arrange using (ZipFile zipFile = new ZipFile()) { ZipDatabaseArchiveFactory factory = new ZipDatabaseArchiveFactory(); factory.ManifestReader = new Mock <IManifestReader>().Object; string fileName = this.CreateTempFile(); zipFile.Save(fileName); // Act IDatabaseArchive archive = factory.Create(fileName); // Assert Assert.Equal(fileName, archive.ArchivePath); } }
public void ShouldCreateAZipDatabaseArchive() { using (ZipFile zipFile = new ZipFile()) { // Arrange ZipDatabaseArchiveFactory factory = new ZipDatabaseArchiveFactory(); factory.ManifestReader = new Mock <IManifestReader>().Object; string fileName = this.CreateTempFile(); zipFile.Save(fileName); // Act IDatabaseArchive archive = factory.Create(fileName); // Assert Assert.IsType <ZipDatabaseArchive>(archive); } }
public IDatabaseVersion Read(Stream stream, string manifestPath, IDatabaseArchive archive) { Validate.NotNull(() => stream); Validate.NotNull(() => manifestPath); Validate.NotNull(() => archive); XmlReader reader = XmlReader.Create(stream); reader.MoveToContent(); XElement element = XElement.ReadFrom(reader) as XElement; string versionString = element.Attributes().First(a => a.Name == "version").Value; VersionBase version = this.VersionProvider.CreateVersion(versionString); DatabaseVersion databaseVersion = new DatabaseVersion(version, manifestPath, archive); databaseVersion.Tasks = CreateTasks(element, databaseVersion); return(databaseVersion); }
/// <summary> /// Checks whether the database has all the versions and tasks installed. /// </summary> /// <param name="arguments">The command line arguments.</param> /// <param name="archive">The database archive.</param> /// <returns>true if no errors occurred, otherwise false.</returns> private bool CheckDatabase(CreateArguments arguments, IDatabaseArchive archive) { bool errorOccurred = false; bool isDatabaseUpToDate = true; using (var sessionFactory = this.SessionFactoryProvider.CreateSessionFactory()) using (var session = sessionFactory.OpenSession()) using (session.BeginTransaction()) { if (!this.VersionProvider.VersionTableExists(session)) { this.MessageService.WriteLine("No versions are currently installed."); return(true); } if (!string.IsNullOrEmpty(arguments.Version)) { isDatabaseUpToDate = CheckSpecificVersion(arguments, archive, session, out errorOccurred); } else { foreach (var version in archive.Versions.OrderBy(v => v.Version, this.VersionProvider.GetComparer()) ) { if (!this.CheckVersion(session, version)) { isDatabaseUpToDate = false; } } } } if (isDatabaseUpToDate) { this.MessageService.WriteLine("The database is up to date."); } return(!errorOccurred); }
/// <summary> /// Checks whether a specific version has been installed in the database. /// </summary> /// <param name="arguments">The command line arguments</param> /// <param name="archive">The database archive.</param> /// <param name="session">The database session.</param> /// <param name="errorOccurred">true if an error occurs, otherwise false.</param> /// <returns>true if the version and all its tasks exist, otherwise false.</returns> private bool CheckSpecificVersion(CreateArguments arguments, IDatabaseArchive archive, ISession session, out bool errorOccurred) { errorOccurred = false; var targetVersion = this.VersionProvider.CreateVersion(arguments.Version); var archiveVersion = archive.Versions .SingleOrDefault( v => this.VersionProvider.GetComparer().Compare(v.Version, targetVersion) == 0); if (archiveVersion != null) { return(this.CheckVersion(session, archiveVersion)); } this.MessageService.WriteLine(string.Format("Version {0} does not exist in the archive.", arguments.Version)); errorOccurred = true; return(false); }
protected abstract bool Execute(string[] args, T arguments, IDatabaseArchive archive);
/// <summary> /// Creates a database at the specified version or upgrades the existing database to the specified version. /// </summary> /// <param name="archive">The archive containing the tasks to run.</param> /// <param name="version">The version of database to create.</param> /// <param name="executer">The object used to execute the tasks.</param> /// <param name="commit">true if any changes should be committed, false if they should be rolled back.</param> /// <param name="executeMissingTasks">true if any missing tasks detected should be executed, otherwise false.</param> /// <returns>Returns the result of Executing the Command</returns> /// <exception cref="VersionNotFoundException"> /// Thrown if the version to create could not be found. /// </exception> /// <exception cref="TaskExecutionException"> /// Thrown if an error occurs while executing one of the tasks in the archive. /// </exception> public bool Create(IDatabaseArchive archive, string version, ITaskExecuter executer, bool commit, bool executeMissingTasks) { using (var sessionFactory = this.SessionFactoryProvider.CreateSessionFactory()) { using (var session = sessionFactory.OpenSession()) { // Set the session to always flush to make sure we execute everything // in order session.FlushMode = NHibernate.FlushMode.Always; using (var transaction = session.BeginTransaction()) { LogUpdateStart(); if (!this.VersionProvider.VersionTableExists(session)) { this.VersionProvider.CreateVersionTable(session); } VersionBase currentVersion = this.VersionProvider.GetCurrentVersion(session); //Log the current version MessageService.WriteLine(currentVersion == null ? "Current Database Version Unknown" : string.Format("Current Database Version: {0}", currentVersion)); VersionBase targetVersion; bool targetVersionSpecified = !string.IsNullOrEmpty(version); if (!targetVersionSpecified) { targetVersion = archive.Versions .OrderByDescending(v => v.Version, this.VersionProvider.GetComparer()) .First() .Version; } else { targetVersion = this.VersionProvider.CreateVersion(version); } MessageService.WriteLine(string.Format("Target Version: {0}", targetVersion)); if (!archive.ContainsVersion(targetVersion)) { MessageService.WriteLine(string.Format("Target Version Not Found in Archive")); throw new VersionNotFoundException(targetVersion); } this.AddTasksToExecuter(archive, executer, currentVersion, targetVersion, executeMissingTasks, session, targetVersionSpecified); executer.ExecuteTasks(session); if (commit) { transaction.Commit(); } else { transaction.Rollback(); } LogUpdateComplete(commit); } } } return(true); }
public DatabaseVersion(VersionBase version, string manifestPath, IDatabaseArchive archive) { this.Version = version; this.ManifestPath = manifestPath; this.Archive = archive; }