public void ShouldRetrieveCurrentVersionFromDatabaseForComparison()
{
// Arrange
var command = CreateCommand();
var version1 = CreateVersionWithTask("1.1", "Task 1");
archive.Setup(a => a.Versions).Returns(new[] { version1.Object });
var versionObject = version1.Object.Version;
var expectedVersion = new ClassicVersion("1.1");
versionProvider.Setup(p => p.GetVersion(this.session.Object, versionObject)).Returns(expectedVersion);
// Act
command.Execute(new string[] { });
// Assert
VersionBase actualVersion = null;
versionProvider.Verify(
v =>
v.HasExecutedScript(It.Is <VersionBase>(vo => CatchVersion(vo, out actualVersion)), It.IsAny <VersionBase>(),
It.IsAny <IDatabaseTask>()));
Assert.Same(expectedVersion, actualVersion);
}
/// <summary>
/// Gets the specified version from the database.
/// </summary>
/// <param name="session">The database connection.</param>
/// <param name="version">The version to get.</param>
/// <returns>The version or null if the version has not been installed in the database.</returns>
public VersionBase GetVersion(ISession session, VersionBase version)
{
var classicVersion = version as ClassicVersion;
return
(session.QueryOver <ClassicVersion>().Where(v => v.Version == classicVersion.Version).SingleOrDefault());
}
/// <summary>
/// Inserts the specified version into the version table.
/// </summary>
/// <param name="version">The version to insert.</param>
/// <param name="session">The database connection.</param>
public void InsertVersion(VersionBase version, ISession session)
{
ClassicVersion classicVersion = version as ClassicVersion;
if (!classicVersion.CreatedOn.HasValue)
{
classicVersion.CreatedOn = DateTime.UtcNow;
}
classicVersion.UpdatedOn = DateTime.UtcNow;
session.SaveOrUpdate(version);
}
public void InsertVersion(VersionBase version, ISession session)
{
NumericVersion numericVersion = version as NumericVersion;
if (!numericVersion.CreatedOn.HasValue)
{
numericVersion.CreatedOn = DateTime.UtcNow;
}
numericVersion.UpdatedOn = DateTime.UtcNow;
session.SaveOrUpdate(version);
}
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);
}
/// <summary>
/// Returns whether a script belongs to the current version and if so whether it has already been executed
/// </summary>
/// <param name="currentVersion"></param>
/// <param name="targetVersion"></param>
/// <param name="task"></param>
/// <returns></returns>
public bool HasExecutedScript(VersionBase currentVersion, VersionBase targetVersion, IDatabaseTask task)
{
if (currentVersion != null)
{
ClassicVersion currentClassicVersion = currentVersion as ClassicVersion;
ClassicVersion targetClassicVersion = targetVersion as ClassicVersion;
if (currentClassicVersion.SystemVersion.Equals(targetClassicVersion.SystemVersion))
{
return(currentClassicVersion.HasExecutedTask(task));
}
}
return(false);
}
public bool HasExecutedScript(VersionBase currentVersion, VersionBase targetVersion, IDatabaseTask task)
{
if (currentVersion != null)
{
NumericVersion currentNumericVersion = currentVersion as NumericVersion;
NumericVersion targetNumericVersion = targetVersion as NumericVersion;
if (currentNumericVersion.Version.Equals(targetNumericVersion.Version))
{
return(currentNumericVersion.HasExecutedTask(task));
}
}
return(false);
}
/// <summary>
/// Writes the specified version.
/// </summary>
/// <param name='version'>
/// The version to write.
/// </param>
/// <param name='arguments'>
/// The command arguments.
/// </param>
private void WriteVersion(VersionBase version, HistoryArguments arguments)
{
string versionString = string.Format(
"{0} Installed - {1}, Updated - {2}",
version.VersionText,
version.CreatedOnLocal,
version.UpdatedOnLocal);
this.MessageService.WriteLine(versionString);
if (arguments.ShowTasks)
{
this.WriteTasks(version, arguments.SortOrder);
}
}
protected override void OnInitializing()
{
//保证下次从主目录启动
VersionBase.RegApp();
//更新其他的文件
var file = DirectoryEx.Update.GetFile("package.xml");
if (file != null)
{
XElement xe = XElement.Load(file.FullName);
UpdateFiles(xe, DirectoryEx.Root, true);
}
UnzipExts();
}
public Boolean Equals(VersionBase <TValue> version)
{
if (ReferenceEquals(version, null))
{
return(false);
}
if (ReferenceEquals(version, this))
{
return(true);
}
return(Id == version.Id &&
VersionedId == version.VersionedId &&
Added == version.Added &&
ValueEqualityComparer.Equals(Value, version.Value));
}
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 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>
/// Execute the command with the specified arguments.
/// </summary>
/// <param name='args'>
/// The arguments.
/// </param>
/// <returns>Returns the result of Executing the Command</returns>
protected override bool Execute(string[] args, HistoryArguments arguments, dbversion.Archives.IDatabaseArchive archive)
{
VersionBase requiredVersion = null;
if (!string.IsNullOrEmpty(arguments.Version))
{
requiredVersion = this.VersionProvider.CreateVersion(arguments.Version);
}
using (var sessionFactory = this.SessionFactoryProvider.CreateSessionFactory())
{
using (var session = sessionFactory.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
if (!this.VersionProvider.VersionTableExists(session))
{
this.MessageService.WriteLine("No versions are currently installed.");
return(false);
}
var sortedVersions = this.GetSortedVersions(arguments, requiredVersion, session);
if (sortedVersions.Count() == 0 && requiredVersion != null)
{
this.MessageService.WriteLine(
string.Format("The specified version, {0}, was not found.", arguments.Version));
return(false);
}
foreach (var version in sortedVersions)
{
this.WriteVersion(version, arguments);
}
transaction.Commit();
}
}
}
return(true);
}
/// <summary>
/// Checks whether all the tasks in the specified version have been run.
/// </summary>
/// <param name="version">The database version.</param>
/// <param name="installedVersion">The current installed version.</param>
/// <returns>true if all the tasks have been installed, otherwise false.</returns>
private bool CheckTasks(IDatabaseVersion version, VersionBase installedVersion)
{
bool hasOutputVersion = false;
bool allTasksInstalled = true;
foreach (var task in version.Tasks)
{
if (!this.VersionProvider.HasExecutedScript(installedVersion, version.Version, task))
{
if (!hasOutputVersion)
{
this.MessageService.WriteLine(string.Format("Version {0} missing:", version.Version.VersionText));
hasOutputVersion = true;
}
this.MessageService.WriteLine(" " + task.FileName);
allTasksInstalled = false;
}
}
return(allTasksInstalled);
}
/// <summary>
/// Writes the tasks.
/// </summary>
/// <param name='version'>
/// The version containing the tasks.
/// </param>
/// <param name='sortOrder'>
/// The order to write the tasks in.
/// </param>
private void WriteTasks(VersionBase version, HistoryOrder sortOrder)
{
IEnumerable <Task> sortedTasks;
if (sortOrder == HistoryOrder.asc || sortOrder == HistoryOrder.Ascending)
{
sortedTasks = version.Tasks.OrderBy(t => t.ExecutionOrder);
}
else
{
sortedTasks = version.Tasks.OrderByDescending(t => t.ExecutionOrder);
}
foreach (var task in sortedTasks)
{
string taskString = string.Format(
" {0} - {1}",
task.Name,
task.UpdatedOnLocal);
this.MessageService.WriteLine(taskString);
}
}
private bool CatchVersion(VersionBase input, out VersionBase actualVersion)
{
actualVersion = input;
return(true);
}
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);
}
}
/// <summary>
/// Gets the versions sorted in the correct order.
/// </summary>
/// <returns>
/// The sorted versions.
/// </returns>
/// <param name='arguments'>
/// The command arguments.
/// </param>
/// <param name='session'>
/// The NHibernate session.
/// </param>
private IEnumerable <VersionBase> GetSortedVersions(HistoryArguments arguments, VersionBase version, NHibernate.ISession session)
{
var versions = this.VersionProvider.GetAllVersions(session);
if (arguments.SortOrder == HistoryOrder.asc || arguments.SortOrder == HistoryOrder.Ascending)
{
versions = versions.OrderBy(v => v, this.VersionProvider.GetComparer());
}
else
{
versions = versions.OrderByDescending(v => v, this.VersionProvider.GetComparer());
}
if (version != null)
{
return(versions.Where(v => object.Equals(v, version)));
}
return(versions);
}
public InsertVersionTask(IVersionProvider versionProvider, VersionBase version, IMessageService messageService)
: base(String.Empty, -1, messageService)
{
this._versionProvider = versionProvider;
this._version = version;
}
/// <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 VersionBase GetVersion(ISession session, VersionBase requiredVersion)
{
var numericVersion = requiredVersion as NumericVersion;
return(session.QueryOver <NumericVersion>().Where(v => v.Version == numericVersion.Version).SingleOrDefault());
}
