private void AddTasksForVersions(ITaskExecuter executer, IEnumerable <IDatabaseVersion> versionsToExecute, ISession session)
{
foreach (IDatabaseVersion v in versionsToExecute)
{
bool hasTasksForVersion = false;
var installedVersion = this.VersionProvider.GetVersion(session, v.Version);
var updateVersion = installedVersion ?? v.Version;
foreach (var task in v.Tasks.OrderBy(t => t.ExecutionOrder))
{
if (!this.VersionProvider.HasExecutedScript(installedVersion, v.Version, task))
{
executer.AddTask(task);
updateVersion.AddTask(task);
hasTasksForVersion = true;
}
}
if (hasTasksForVersion)
{
executer.AddTask(new InsertVersionTask(this.VersionProvider, updateVersion, this.MessageService));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkerActor"/> class
/// </summary>
/// <param name="executer">Executer object</param>
public WorkerActor(ITaskExecuter executer)
{
_taskExecuter = executer;
Receive <JobStartedMessage>(job => HandleJobExecute(job));
Receive <AcknowledgementMessage>(message => HandleAcknowldgement(message));
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkerActor"/> class
/// </summary>
/// <param name="executer">Executer object</param>
public WorkerActor(ITaskExecuter executer)
{
_taskExecuter = executer;
Receive <JobStartedMessage>(job => HandleJobExecute(job));
Receive <AcknowledgementMessage>(message => HandleAcknowldgement(message));
_logger.Debug("Worker instance created.");
}
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>
/// 给ITaskExecuter添加task
/// <para>executer task执行者</para>
/// <para>lua Func task函数</para>
/// </summary>
/// <param name="luaState"></param>
/// <returns></returns>
public static int AddTask(ILuaState luaState)
{
ITaskExecuter executer = luaState.ToUserData(-2) as ITaskExecuter;
int funcRef = luaState.L_Ref(LuaDef.LUA_REGISTRYINDEX);
luaState.Pop(1);
Task task = ObjectsPool.GetInstance().GetPoolClassAtPool <Task>();
task.funcRef = funcRef;
executer.AddTask(task);
return(0);
}
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);
}
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);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="writer">Frame writer to be wrapped.</param>
public StompSerialFrameWriter(IStompFrameWriter writer)
{
_writer = writer;
_serialTaskExecuter = new SerialTaskExecuter();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="reader">Frame reader to be wrapped.</param>
public StompSerialFrameReader(IStompFrameReader reader)
{
_reader = reader;
_serialTaskExecuter = new SerialTaskExecuter <Frame>();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="writer">Frame writer to be wrapped.</param>
public StompSerialFrameWriter(IStompFrameWriter writer)
{
_writer = writer;
_serialTaskExecuter = new SerialTaskExecuter();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="reader">Frame reader to be wrapped.</param>
public StompSerialFrameReader(IStompFrameReader reader)
{
_reader = reader;
_serialTaskExecuter = new SerialTaskExecuter<Frame>();
}
/// <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);
}
