public void Run(TaskRunContext task) { _resourcesLock.EnterReadLock(); try { Log.Info("Running task " + task.ToString()); string resourceName = task.NodesConfig.First().ResourceName; var resourceCache = ResourceCache.GetByName(resourceName); lock (resourceCache.StateLock) { CheckNodeConfigConsistency(task.TaskId, task.NodesConfig, resourceCache.Resource); task.Resource = resourceCache.Resource; task.Controller = resourceCache.Controller; } try { resourceCache.Acquire(task.NodesConfig); // todo : m.b. move under resourceCache.StateLock? Log.Info(String.Format("Trying to run task {0} on resource {1}", task.TaskId, task.Resource.ResourceName)); task.LocalId = task.Controller.Run(task); Log.Info(String.Format("Task {0} ({1}) started on resource {2} with localId = {3}", task.TaskId, task.PackageName, task.Resource.ResourceName, task.LocalId )); var state = new TaskStateInfo(TaskState.Started, task.LocalId.ToString()); TaskCache.AddTask(task, state); } catch (Exception e) { resourceCache.Release(task.NodesConfig); Log.Error(String.Format("Unable to run task {0}: {1}", task.TaskId, e)); throw; } } catch (Exception e) { Log.Error(String.Format("Exception on Farm.Run(task {0}): {1}", task.TaskId, e)); throw; } finally { _resourcesLock.ExitReadLock(); } //todo for mock if (CacheCollectorFactory.CheckMockMode()) { CacheCollectorFactory.GetInstance().SendTask(task); } }
public TaskStateInfo GetTaskStateInfo(ulong taskId) { _resourcesLock.EnterReadLock(); try { var task = TaskCache.GetById(taskId); task.UpdateStateAsync(); lock (task.StateInfo) { var taskState = new TaskStateInfo(task.StateInfo); return(taskState); } } catch (Exception e) { Log.Error(String.Format("Error on getting task {0} state info: {1}", taskId, e)); throw; } finally { _resourcesLock.ExitReadLock(); } }
public static void AddTask(TaskRunContext context, TaskStateInfo state) //, TaskState state = TaskState.Started, string stateComment = "") { var taskCache = new TaskCache(context, state, CacheCollectorFactory.GetInstance().GetTaskCacheCollector()); // autosaves lock (_globalLock) { _cache[context.TaskId] = taskCache; } }
public static void AddTask(TaskRunContext context, TaskState state = TaskState.Started, string stateComment = "") { var taskCache = new TaskCache(context, state, stateComment); lock (_globalLock) { _cache[context.TaskId] = taskCache; } }
public void ReloadAllResources(string dumpingKey = null) { PFX.Task.Factory.StartNew(() => { _resourcesLock.EnterWriteLock(); // the only update (i.e. write) to resources try { Log.Info("Reloading resources for controller"); Console.WriteLine("Reloading resources for controller"); TaskCache.DumpAllTasks(); var resourceBase = new ResourceBaseServiceClient(); try { string farmId = Config.AppSettings[FARMID_PARAM_NAME]; var resources = resourceBase.GetResourcesForFarm(farmId, dumpingKey); // waits all other dumps resourceBase.Close(); string[] resourceNames = resources.Select(r => r.ResourceName).ToArray(); Log.Info("Resources to reload for farm " + farmId + ": " + String.Join(", ", resourceNames)); ResourceCache.ReloadResources(resources); TaskCache.RestoreTasks(resourceNames); //TaskCache.ReloadTasks(resourceNames); PFX.Parallel.ForEach(resourceNames, (name) => { ResourceCache.UpdateNodesState(name); }); Log.Info("Resource reloading done for farm " + farmId); } catch (Exception e) { resourceBase.Abort(); Log.Error("Exception on reloading resources: " + e.ToString()); throw; } } finally { _resourcesLock.ExitWriteLock(); } }); }
private static void SetControllerForLoadedTask(TaskCache task) { try { // DO NOT USE CURRENT CACHED CONTROLLER: could have changed parts from the task's one. Also, controllers should be stateless task.Context.Controller = ControllerBuilder.Build(task.Context.Resource); } catch (Exception buildEx) { Log.Warn(String.Format("Could not build controller for loaded task {0}: {1}", task.Context.TaskId, buildEx )); } task.Context.Controller = null; }
private TaskStatInfo GetCacheableInfoForTask(ulong id, DateTime date) { var task = TaskCache.GetById(id); //todo ask Sergey or Denis about states IStatisticalCacheableController controller = task.Context.Controller as IStatisticalCacheableController; if (controller != null) { var infos = controller.GetTaskInfoStartWith(id, date, task.Context); var statInfo = new TaskStatInfo(infos, task.Context.Resource.ResourceName); return(statInfo); } return(null); }
public ulong[] GetActiveTaskIds() { _resourcesLock.EnterReadLock(); try { ulong[] ids = TaskCache.GetActiveTaskIds(); return(ids); } catch (Exception e) { Log.Error("Error on getting active tasks ids: " + e.ToString()); throw; } finally { _resourcesLock.ExitReadLock(); } }
public static void UpdateStateInfo(ulong taskId, Func <TaskRunContext, TaskStateInfo> updateFunc) { var cache = GetById(taskId); if (!cache._isUpdating && (cache._lastUpdateTime + UPDATE_INTERVAL < DateTime.Now || DateTime.Now < cache._lastUpdateTime)) { lock (cache._lock) { if (!cache._isUpdating && (cache._lastUpdateTime + UPDATE_INTERVAL < DateTime.Now || DateTime.Now < cache._lastUpdateTime)) { cache._isUpdating = true; var newState = updateFunc(cache.Context); var newCache = new TaskCache(cache.Context, newState); lock (_globalLock) // unnecessary? { _cache[taskId] = newCache; } } } } }
public void Abort(ulong taskId) { _resourcesLock.EnterReadLock(); try { Log.Info("Aborting task " + taskId.ToString()); var task = TaskCache.GetById(taskId); task.UpdateStateAsync(); lock (task.StateLock) { if (task.StateInfo.State == TaskState.Started) { task.Context.Controller.Abort(task.Context); Log.Info("Task aborted: " + taskId.ToString()); task.SetState(TaskState.Aborted, "Aborted by request"); // autorelease resources } else { Log.Warn("Task was not started: " + taskId.ToString()); } } } catch (Exception e) { Log.Error(String.Format("Error on aborting task {0}: {1}}", taskId, e)); throw; } finally { _resourcesLock.ExitReadLock(); } }
public static void UpdateStateInfo(ulong taskId, Func<TaskRunContext, TaskStateInfo> updateFunc) { var cache = GetById(taskId); if (!cache._isUpdating && (cache._lastUpdateTime + UPDATE_INTERVAL < DateTime.Now || DateTime.Now < cache._lastUpdateTime)) { lock (cache._lock) { if (!cache._isUpdating && (cache._lastUpdateTime + UPDATE_INTERVAL < DateTime.Now || DateTime.Now < cache._lastUpdateTime)) { cache._isUpdating = true; var newState = updateFunc(cache.Context); var newCache = new TaskCache(cache.Context, newState); lock (_globalLock) // unnecessary? { _cache[taskId] = newCache; } } } } }
//, TaskState state = TaskState.Started, string stateComment = "") public static void AddTask(TaskRunContext context, TaskStateInfo state) { var taskCache = new TaskCache(context, state, CacheCollectorFactory.GetInstance().GetTaskCacheCollector()); // autosaves lock (_globalLock) { _cache[context.TaskId] = taskCache; } }