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="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); }