use of cz.metacentrum.perun.taskslib.model.Task in project perun by CESNET.
the class PropagationStatsReaderImpl method getResourcesState.
@Override
public List<ResourceState> getResourcesState(PerunSession session, Vo vo) throws PrivilegeException, VoNotExistsException, InternalErrorException {
List<Resource> resources = perun.getResourcesManager().getResources(session, vo);
List<ResourceState> resourceStateList = new ArrayList<ResourceState>();
for (Resource resource : resources) {
List<Task> taskList = taskManager.listAllTasksForFacility(resource.getFacilityId());
// filter SEND tasks
Iterator<Task> iterator = taskList.iterator();
while (iterator.hasNext()) {
if (!(iterator.next().getExecService().getExecServiceType().equals(ExecService.ExecServiceType.SEND))) {
iterator.remove();
}
}
// create new resourceState
ResourceState resourceState = new ResourceState();
resourceState.setResource(resource);
resourceState.setTaskList(taskList);
// add new created resourceState to List
resourceStateList.add(resourceState);
}
return resourceStateList;
}
use of cz.metacentrum.perun.taskslib.model.Task in project perun by CESNET.
the class PropagationStatsReaderImpl method getFacilityServicesState.
@Override
public List<ServiceState> getFacilityServicesState(PerunSession sess, Facility facility) throws ServiceNotExistsException, InternalErrorException, PrivilegeException {
if (!AuthzResolver.isAuthorized(sess, Role.FACILITYADMIN, facility)) {
throw new PrivilegeException("getFacilityServicesState");
}
Map<Service, ServiceState> serviceStates = new HashMap<Service, ServiceState>();
// fill states for all services which are currently on facility
for (Service service : perun.getServicesManagerBl().getAssignedServices(sess, facility)) {
serviceStates.put(service, new ServiceState(service, facility));
try {
// fill global allowance state based on existing exec services
List<ExecService> execs = getGeneralServiceManager().listExecServices(sess, service.getId());
for (ExecService ex : execs) {
if (!ex.isEnabled())
serviceStates.get(service).setBlockedGlobally(true);
// fill facility allowance state based on existing exec services
if (getGeneralServiceManager().isExecServiceDeniedOnFacility(ex, facility))
serviceStates.get(service).setBlockedOnFacility(true);
}
} catch (EmptyResultDataAccessException ex) {
// service has no exec services -> blocked globally
serviceStates.get(service).setBlockedGlobally(true);
}
// service has destination on facility
serviceStates.get(service).setHasDestinations(!perun.getServicesManagerBl().getDestinations(sess, service, facility).isEmpty());
}
// fill states for all tasks on facility
List<Task> tasks = taskDao.listAllTasksForFacility(facility.getId());
for (Task task : tasks) {
Service taskService = task.getExecService().getService();
ServiceState serviceState = serviceStates.get(taskService);
if (serviceState == null) {
serviceState = new ServiceState(taskService, facility);
serviceStates.put(taskService, serviceState);
// fill destinations if service was not assigned
serviceStates.get(taskService).setHasDestinations(!perun.getServicesManagerBl().getDestinations(sess, taskService, facility).isEmpty());
}
// fill service state
if (ExecService.ExecServiceType.GENERATE.equals(task.getExecService().getExecServiceType())) {
serviceState.setGenTask(task);
} else {
serviceState.setSendTask(task);
}
if (!task.getExecService().isEnabled()) {
serviceStates.get(taskService).setBlockedGlobally(true);
}
if (getGeneralServiceManager().isExecServiceDeniedOnFacility(task.getExecService(), facility))
serviceStates.get(taskService).setBlockedOnFacility(true);
}
return new ArrayList<ServiceState>(serviceStates.values());
}
use of cz.metacentrum.perun.taskslib.model.Task in project perun by CESNET.
the class PropagationMaintainerImpl method setAllGenerateDependenciesToNone.
/*
* @Override public Statistics getStatistics() { throw new
* UnsupportedOperationException("Nah..."); }
*/
private void setAllGenerateDependenciesToNone(Task task) {
List<ExecService> dependencies = this.dependenciesResolver.listDependencies(task.getExecService());
for (ExecService dependencyToBeSetDirty : dependencies) {
if (dependencyToBeSetDirty.getExecServiceType().equals(ExecServiceType.GENERATE)) {
Task taskToBeSetDirty = schedulingPool.getTask(dependencyToBeSetDirty, task.getFacility());
if (taskToBeSetDirty != null) {
log.debug("Setting GEN dependency task {} to NONE state to regenerate data for completed task {}", taskToBeSetDirty, task);
schedulingPool.setTaskStatus(taskToBeSetDirty, TaskStatus.NONE);
try {
schedulingPool.setQueueForTask(taskToBeSetDirty, null);
} catch (InternalErrorException e) {
log.error("Could not set destination queue for task {}: {}", task.getId(), e.getMessage());
}
}
}
}
}
use of cz.metacentrum.perun.taskslib.model.Task in project perun by CESNET.
the class PropagationMaintainerImpl method rescheduleErrorTasks.
private void rescheduleErrorTasks() {
log.info("I am gonna list tasks in ERROR and reschedule if necessary...");
for (Task task : schedulingPool.getErrorTasks()) {
if (task.getEndTime() == null) {
log.error("RECOVERY FROM INCONSISTENT STATE: ERROR task does not have end_time! Setting end_time to task.getDelay + 1.");
// getDelay is in minutes, therefore we multiply it with 60*1000
Date endTime = new Date(System.currentTimeMillis() - ((task.getDelay() + 1) * 60000));
task.setEndTime(endTime);
}
int howManyMinutesAgo = (int) (System.currentTimeMillis() - task.getEndTime().getTime()) / 1000 / 60;
if (howManyMinutesAgo < 0) {
log.error("RECOVERY FROM INCONSISTENT STATE: ERROR task appears to have ended in future.");
Date endTime = new Date(System.currentTimeMillis() - ((task.getDelay() + 1) * 60000));
task.setEndTime(endTime);
howManyMinutesAgo = task.getDelay() + 1;
}
log.info("TASK [" + task + "] in ERROR state completed " + howManyMinutesAgo + " minutes ago.");
// XXX - apparently this is not what the authors had in mind,
// commented out
// check and set recurrence
// int recurrence = task.getRecurrence() - 1;
// if(recurrence < 0) {
// // no more retries, sorry
// log.info("TASK [ " + task +
// "] in ERROR state has no more retries, bailing out.");
// continue;
// }
// task.setRecurrence(recurrence);
// If DELAY time has passed, we reschedule...
int recurrence = task.getRecurrence() + 1;
if (recurrence > task.getExecService().getDefaultRecurrence() && howManyMinutesAgo < 60 * 12 && !task.isSourceUpdated()) {
log.info("TASK [ " + task + "] in ERROR state has no more retries, bailing out.");
} else if (howManyMinutesAgo >= recurrence * task.getDelay() || task.isSourceUpdated()) {
// check if service is still assigned on facility
try {
List<Service> assignedServices = perun.getServicesManager().getAssignedServices(perunSession, task.getFacility());
if (assignedServices.contains(task.getExecService().getService())) {
ExecService execService = task.getExecService();
Facility facility = task.getFacility();
if (recurrence > execService.getDefaultRecurrence()) {
// this ERROR task is rescheduled for being here too long
task.setRecurrence(0);
task.setDestinations(null);
log.info("TASK id " + task.getId() + " is in ERROR state long enough, ");
}
task.setRecurrence(recurrence);
log.info("TASK [" + task + "] in ERROR state is going to be rescheduled: taskScheduler.propagateService(execService:ID " + execService.getId() + ", new Date(System.currentTimeMillis()), facility:ID " + facility.getId() + ");");
// taskScheduler.propagateService(task, new
// Date(System.currentTimeMillis()));
taskScheduler.scheduleTask(task);
log.info("TASK [" + task + "] in ERROR state has been rescheduled.");
// Also (to be sure) reschedule all Tasks that depend on
// this Task
//
// While engine starts in state GEN = ERROR, SEND = DONE
// => GEN will be rescheduled but without this SEND will
// never be propagated
List<ExecService> dependantServices = dependenciesResolver.listDependantServices(execService);
for (ExecService dependantService : dependantServices) {
Task dependantTask = schedulingPool.getTask(dependantService, facility);
if (dependantTask == null) {
dependantTask = new Task();
dependantTask.setExecService(dependantService);
dependantTask.setFacility(facility);
dependantTask.setRecurrence(dependantService.getDefaultRecurrence());
schedulingPool.addToPool(dependantTask, schedulingPool.getQueueForTask(task));
taskScheduler.scheduleTask(dependantTask);
log.info("{} was rescheduled because it depends on {}", dependantTask, task);
}
}
} else {
// delete this tasks (SEND and GEN) because service is
// no longer assigned to facility
schedulingPool.removeTask(task);
log.warn("Removed TASK {} from database, beacuse service is no longer assigned to this facility.", task.toString());
}
} catch (FacilityNotExistsException e) {
schedulingPool.removeTask(task);
log.error("Removed TASK {} from database, facility no longer exists.", task.getId());
} catch (InternalErrorException e) {
log.error("{}", e);
} catch (PrivilegeException e) {
log.error("Consistency error. {}", e);
}
}
}
/*
* Original implementation:
*
* //TODO: Take into account Recurrence! for (Task task :
* taskManager.listAllTasksInState(TaskStatus.ERROR,
* Integer.parseInt(propertiesBean.getProperty("engine.unique.id")))) {
* if (task.getEndTime() == null) { log.error(
* "RECOVERY FROM INCONSISTATE STATE: ERROR task does not have end_time! Setting end_time to task.getDelay + 1."
* ); // getDelay is in minutes, therefore we multiply it with 60*1000
* Date endTime = new Date(System.currentTimeMillis() -
* ((task.getDelay() + 1) * 60000)); task.setEndTime(endTime);
* taskManager.updateTask(task,
* Integer.parseInt(propertiesBean.getProperty("engine.unique.id"))); }
* int howManyMinutesAgo = (int) (System.currentTimeMillis() -
* task.getEndTime().getTime()) / 1000 / 60; log.info("TASK [" + task +
* "] in ERROR state completed " + howManyMinutesAgo + " minutes ago.");
* //If DELAY time has passed, we reschedule... if (howManyMinutesAgo >=
* task.getDelay()) { //check if service is still assigned on facility
* try { List<Service> assignedServices =
* Rpc.ServicesManager.getAssignedServices(engineManager.getRpcCaller(),
* task.getFacility());
* if(assignedServices.contains(task.getExecService().getService())) {
* try { taskManager.updateTask(task,
* Integer.parseInt(propertiesBean.getProperty("engine.unique.id")));
* ExecService execService = task.getExecService(); Facility facility =
* task.getFacility(); log.info("TASK [" + task +
* "] in ERROR state is going to be rescheduled: taskScheduler.propagateService(execService:ID "
* + execService.getId() +
* ", new Date(System.currentTimeMillis()), facility:ID " +
* facility.getId() + ");"); taskScheduler.propagateService(execService,
* new Date(System.currentTimeMillis()), facility); log.info("TASK [" +
* task + "] in ERROR state has been rescheduled.");
*
* //Also (to be sure) reschedule all execServices which depends on this
* exec service // //While engine starts in state GEN = ERROR, SEND =
* DONE => GEN will be rescheduled but without this SEND will never be
* propagated List<ExecService> dependentExecServices =
* Rpc.GeneralServiceManager
* .listExecServicesDependingOn(engineManager.getRpcCaller(),
* execService); if(dependentExecServices != null) { for(ExecService
* dependantExecService : dependentExecServices) {
* taskScheduler.propagateService(dependantExecService, new
* Date(System.currentTimeMillis()), facility);
* log.info("{} was rescheduled because it depends on {}",
* dependantExecService, execService); } }
*
* } catch (InternalErrorException e) { log.error(e.toString(), e); } }
* else { //delete this tasks (SEND and GEN) because service is no
* longer assigned to facility List<ExecService> execServicesGenAndSend
* =
* Rpc.GeneralServiceManager.listExecServices(engineManager.getRpcCaller
* (), task.getExecService().getService().getId()); for(ExecService
* execService : execServicesGenAndSend) { Task taskToDelete =
* taskManager.getTask(execService, task.getFacility(),
* Integer.parseInt(propertiesBean.getProperty("engine.unique.id")));
* if(taskToDelete!= null) {
* resultManager.clearByTask(taskToDelete.getId(),
* Integer.parseInt(propertiesBean.getProperty("engine.unique.id")));
* taskManager.removeTask(taskToDelete.getId(),
* Integer.parseInt(propertiesBean.getProperty("engine.unique.id"))); }
* } } } catch(PrivilegeException ex) {
* log.error("Consistency error. {}", ex); }
* catch(FacilityNotExistsException ex) {
* log.error("Consistency error - found task for non-existing facility. {}"
* , ex); } catch(ServiceNotExistsException ex) {
* log.error("Consistency error - found task for non-existing service. {}"
* , ex); } catch(InternalErrorException ex) { log.error("{}", ex); } }
* }
*/
}
use of cz.metacentrum.perun.taskslib.model.Task in project perun by CESNET.
the class PropagationMaintainerImpl method closeTasksForEngine.
@Override
public void closeTasksForEngine(int clientID) {
List<Task> tasks = schedulingPool.getTasksForEngine(clientID);
// switch all processing tasks to error, remove the engine queue association
log.debug("Switching PROCESSING tasks on engine {} to ERROR, the engine went down", clientID);
for (Task task : tasks) {
if (task.getStatus().equals(TaskStatus.PROCESSING)) {
log.debug("switching task {} to ERROR, the engine it was running on went down", task.getId());
schedulingPool.setTaskStatus(task, TaskStatus.ERROR);
}
try {
schedulingPool.setQueueForTask(task, null);
} catch (InternalErrorException e) {
log.error("Could not remove output queue for task {}: {}", task.getId(), e.getMessage());
}
}
}
Aggregations