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;
}
}
}
}
}
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;
}
}
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;
}
//, 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;
}
}
