Examples with Task cz.metacentrum.perun.taskslib.model.Task used on opensource projects

Example 11 with Task

use of cz.metacentrum.perun.taskslib.model.Task in project perun by CESNET.

the class SchedulingPoolTest method setup.

@Before
public void setup() throws InternalErrorException {
    task1 = new Task();
    task1.setId(1);
    task1.setExecService(execservice1);
    task1.setFacility(facility1);
    task1.setDestinations(destinations);
    task1.setStatus(TaskStatus.NONE);
    task1.setSchedule(new Date(System.currentTimeMillis()));
    dispatcherQueue = new DispatcherQueue(1, "test-queue");
    schedulingPool.addToPool(task1, dispatcherQueue);
}

Example 12 with Task

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

Example 13 with Task

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());
}

Example 14 with Task

use of cz.metacentrum.perun.taskslib.model.Task in project perun by CESNET.

the class PropagationStatsReaderImpl method getFacilityState.

@Override
public FacilityState getFacilityState(PerunSession session, Facility facility) throws PrivilegeException, FacilityNotExistsException, InternalErrorException {
    // get all tasks
    List<Task> tasks = taskDao.listAllTasksForFacility(facility.getId());
    // define state
    FacilityState state = new FacilityState();
    state.setFacility(facility);
    // if no tasks we can't determine facility state
    if (tasks.isEmpty() || tasks == null) {
        state.setState(FacilityPropagationState.NOT_DETERMINED);
        return state;
    } else {
        // OK if no change
        state.setState(FacilityPropagationState.OK);
    }
    // fill all available destinations
    List<RichDestination> destinations = perun.getServicesManager().getAllRichDestinations(session, facility);
    for (RichDestination rd : destinations) {
        state.getResults().put(rd.getDestination(), FacilityPropagationState.NOT_DETERMINED);
    }
    // magic with tasks :-)
    for (Task task : tasks) {
        // save previous facility state
        FacilityPropagationState facState = state.getState();
        // PROCESSING and not ERROR before
        if (TaskStatus.PROCESSING.equals(task.getStatus()) && (facState != FacilityPropagationState.ERROR)) {
            state.setState(FacilityPropagationState.PROCESSING);
        } else // ERROR - set ERROR
        if (TaskStatus.ERROR.equals(task.getStatus())) {
            state.setState(FacilityPropagationState.ERROR);
        }
        // get destination status
        if (task.getExecService().getExecServiceType().equals(ExecService.ExecServiceType.SEND)) {
            List<TaskResult> results = taskResultDao.getTaskResultsByTask(task.getId());
            Map<Service, Map<Destination, TaskResult>> latestResults = new HashMap<Service, Map<Destination, TaskResult>>();
            for (TaskResult res : results) {
                if (latestResults.get(res.getService()) == null) {
                    // put in map since result for service exists
                    Map<Destination, TaskResult> value = new HashMap<>();
                    value.put(res.getDestination(), res);
                    latestResults.put(res.getService(), value);
                } else if (latestResults.get(res.getService()) != null && latestResults.get(res.getService()).get(res.getDestination()) == null) {
                    // put in inner map, since destination for service not yet exists
                    latestResults.get(res.getService()).put(res.getDestination(), res);
                } else {
                    // update in inner map since this is later task result
                    if (latestResults.get(res.getService()).get(res.getDestination()).getId() < res.getId()) {
                        // put in map
                        latestResults.get(res.getService()).put(res.getDestination(), res);
                    }
                }
            }
            for (Map<Destination, TaskResult> res : latestResults.values()) {
                for (TaskResult result : res.values()) {
                    // iterate over all latest tasks results
                    String destination = result.getDestination().getDestination();
                    FacilityPropagationState propState = state.getResults().get(destination);
                    // if any error => state is error
                    if (TaskResult.TaskResultStatus.ERROR.equals(result.getStatus())) {
                        state.getResults().put(destination, FacilityPropagationState.ERROR);
                        continue;
                    }
                    // if result ok and previous was not bad
                    if (TaskResult.TaskResultStatus.DONE.equals(result.getStatus())) {
                        if (FacilityPropagationState.NOT_DETERMINED.equals(propState)) {
                            state.getResults().put(destination, FacilityPropagationState.OK);
                        }
                    }
                }
            }
        }
    }
    return state;
}

Example 15 with Task

use of cz.metacentrum.perun.taskslib.model.Task in project perun by CESNET.

the class TaskResultDaoTest method testClearOldTaskResult.

@Test
public void testClearOldTaskResult() throws InternalErrorException, PrivilegeException, ServiceExistsException, OwnerNotExistsException, FacilityExistsException, ServiceNotExistsException, FacilityNotExistsException, DestinationAlreadyAssignedException, WrongPatternException {
    System.out.println("TaskResultDao.clearOld");
    Owner testOwner = new Owner();
    testOwner.setContact("Call me");
    testOwner.setName("Tester-" + Long.toHexString(System.currentTimeMillis()));
    testOwner.setType(OwnerType.technical);
    testOwner = ownersManager.createOwner(perunSession, testOwner);
    Service testService = new Service();
    testService.setName("Test_service_1_" + Long.toHexString(System.currentTimeMillis()));
    testService = servicesManager.createService(perunSession, testService);
    Service testService2 = new Service();
    testService2.setName("Test_service_2_" + Long.toHexString(System.currentTimeMillis()));
    testService2 = servicesManager.createService(perunSession, testService2);
    Facility facility = new Facility();
    facility.setName("Facility 1-" + Long.toHexString(System.currentTimeMillis()));
    facility.setDescription("Description");
    facility = facilitiesManager.createFacility(perunSession, facility);
    Facility facility2 = new Facility();
    facility2.setName("Facility 2-" + Long.toHexString(System.currentTimeMillis()));
    facility2.setDescription("Description");
    facility2 = facilitiesManager.createFacility(perunSession, facility2);
    ExecService testExecService = new ExecService();
    testExecService.setDefaultDelay(1);
    testExecService.setDefaultRecurrence(1);
    testExecService.setEnabled(true);
    testExecService.setService(testService);
    testExecService.setScript("serviceGenerate.bash");
    testExecService.setExecServiceType(ExecService.ExecServiceType.GENERATE);
    testExecService.setId(execServiceDao.insertExecService(testExecService));
    ExecService testExecService2 = new ExecService();
    testExecService2.setDefaultDelay(1);
    testExecService2.setDefaultRecurrence(1);
    testExecService2.setEnabled(true);
    testExecService2.setService(testService2);
    testExecService2.setScript("serviceGenerate.bash");
    testExecService2.setExecServiceType(ExecService.ExecServiceType.GENERATE);
    testExecService2.setId(execServiceDao.insertExecService(testExecService2));
    Destination destination1 = new Destination();
    destination1.setDestination("Destination-1-" + Long.toHexString(System.currentTimeMillis()));
    destination1.setType(Destination.DESTINATIONEMAILTYPE);
    destination1 = servicesManager.addDestination(perunSession, testService, facility, destination1);
    Destination destination2 = new Destination();
    destination2.setDestination("Destination-2-" + Long.toHexString(System.currentTimeMillis()));
    destination2.setType(Destination.DESTINATIONEMAILTYPE);
    destination2 = servicesManager.addDestination(perunSession, testService, facility, destination2);
    Destination destination3 = new Destination();
    destination3.setDestination("Destination-3-" + Long.toHexString(System.currentTimeMillis()));
    destination3.setType(Destination.DESTINATIONEMAILTYPE);
    destination3 = servicesManager.addDestination(perunSession, testService2, facility2, destination3);
    Task testTask1 = new Task();
    testTask1.setDelay(10);
    testTask1.setExecService(testExecService);
    testTask1.setFacility(facility);
    testTask1.setRecurrence(10);
    testTask1.setSchedule(new Date());
    testTask1.setStatus(Task.TaskStatus.PROCESSING);
    testTask1.setId(taskDao.scheduleNewTask(testTask1, virtualEngineID));
    Task testTask2 = new Task();
    testTask2.setDelay(10);
    testTask2.setExecService(testExecService2);
    testTask2.setFacility(facility2);
    testTask2.setRecurrence(10);
    testTask2.setSchedule(new Date());
    testTask2.setStatus(Task.TaskStatus.PROCESSING);
    testTask2.setId(taskDao.scheduleNewTask(testTask2, virtualEngineID));
    Calendar cal = Calendar.getInstance();
    cal.add(Calendar.DATE, -2);
    TaskResult taskResult = new TaskResult();
    taskResult.setDestinationId(destination1.getId());
    taskResult.setErrorMessage("error message");
    taskResult.setReturnCode(0);
    taskResult.setStandardMessage("std message");
    taskResult.setStatus(TaskResult.TaskResultStatus.DONE);
    taskResult.setTaskId(testTask1.getId());
    taskResult.setTimestamp(cal.getTime());
    taskResult.setService(testService);
    taskResult.setId(taskResultDao.insertNewTaskResult(taskResult, virtualEngineID));
    TaskResult taskResult2 = new TaskResult();
    taskResult2.setDestinationId(destination3.getId());
    taskResult2.setErrorMessage("error message");
    taskResult2.setReturnCode(0);
    taskResult2.setStandardMessage("std message");
    taskResult2.setStatus(TaskResult.TaskResultStatus.DONE);
    taskResult2.setTaskId(testTask2.getId());
    taskResult2.setTimestamp(cal.getTime());
    taskResult2.setService(testService2);
    taskResult2.setId(taskResultDao.insertNewTaskResult(taskResult2, virtualEngineID));
    cal.add(Calendar.DATE, -5);
    TaskResult oldTaskResult = new TaskResult();
    oldTaskResult.setDestinationId(destination1.getId());
    oldTaskResult.setErrorMessage("error message");
    oldTaskResult.setReturnCode(0);
    oldTaskResult.setStandardMessage("std message");
    oldTaskResult.setStatus(TaskResult.TaskResultStatus.DONE);
    oldTaskResult.setTaskId(testTask1.getId());
    oldTaskResult.setTimestamp(cal.getTime());
    oldTaskResult.setService(testService);
    oldTaskResult.setId(taskResultDao.insertNewTaskResult(oldTaskResult, virtualEngineID));
    TaskResult oldTaskResult2 = new TaskResult();
    oldTaskResult2.setDestinationId(destination3.getId());
    oldTaskResult2.setErrorMessage("error message");
    oldTaskResult2.setReturnCode(0);
    oldTaskResult2.setStandardMessage("std message");
    oldTaskResult2.setStatus(TaskResult.TaskResultStatus.DONE);
    oldTaskResult2.setTaskId(testTask2.getId());
    oldTaskResult2.setTimestamp(cal.getTime());
    oldTaskResult2.setService(testService2);
    oldTaskResult2.setId(taskResultDao.insertNewTaskResult(oldTaskResult2, virtualEngineID));
    TaskResult uniqueTaskResult = new TaskResult();
    uniqueTaskResult.setDestinationId(destination2.getId());
    uniqueTaskResult.setErrorMessage("error message");
    uniqueTaskResult.setReturnCode(0);
    uniqueTaskResult.setStandardMessage("std message");
    uniqueTaskResult.setStatus(TaskResult.TaskResultStatus.DONE);
    uniqueTaskResult.setTaskId(testTask1.getId());
    uniqueTaskResult.setTimestamp(cal.getTime());
    uniqueTaskResult.setService(testService);
    uniqueTaskResult.setId(taskResultDao.insertNewTaskResult(uniqueTaskResult, virtualEngineID));
    TaskResult uniqueTaskResult2 = new TaskResult();
    uniqueTaskResult2.setDestinationId(destination2.getId());
    uniqueTaskResult2.setErrorMessage("error message");
    uniqueTaskResult2.setReturnCode(0);
    uniqueTaskResult2.setStandardMessage("std message");
    uniqueTaskResult2.setStatus(TaskResult.TaskResultStatus.DONE);
    uniqueTaskResult2.setTaskId(testTask2.getId());
    uniqueTaskResult2.setTimestamp(cal.getTime());
    uniqueTaskResult2.setService(testService2);
    uniqueTaskResult2.setId(taskResultDao.insertNewTaskResult(uniqueTaskResult2, virtualEngineID));
    TaskResult foundTaskResult1 = taskResultDao.getTaskResultById(taskResult.getId());
    TaskResult foundTaskResult2 = taskResultDao.getTaskResultById(oldTaskResult.getId());
    TaskResult foundTaskResult3 = taskResultDao.getTaskResultById(uniqueTaskResult.getId());
    TaskResult foundTaskResult4 = taskResultDao.getTaskResultById(taskResult2.getId());
    TaskResult foundTaskResult5 = taskResultDao.getTaskResultById(oldTaskResult2.getId());
    TaskResult foundTaskResult6 = taskResultDao.getTaskResultById(uniqueTaskResult2.getId());
    assertEquals(taskResult, foundTaskResult1);
    assertEquals(oldTaskResult, foundTaskResult2);
    assertEquals(uniqueTaskResult, foundTaskResult3);
    assertEquals(taskResult2, foundTaskResult4);
    assertEquals(oldTaskResult2, foundTaskResult5);
    assertEquals(uniqueTaskResult2, foundTaskResult6);
    taskResultDao.clearOld(virtualEngineID, 6);
    foundTaskResult1 = taskResultDao.getTaskResultById(taskResult.getId());
    foundTaskResult3 = taskResultDao.getTaskResultById(uniqueTaskResult.getId());
    foundTaskResult4 = taskResultDao.getTaskResultById(taskResult2.getId());
    foundTaskResult6 = taskResultDao.getTaskResultById(uniqueTaskResult2.getId());
    assertEquals(taskResult, foundTaskResult1);
    assertEquals(uniqueTaskResult, foundTaskResult3);
    assertEquals(taskResult2, foundTaskResult4);
    assertEquals(uniqueTaskResult2, foundTaskResult6);
    try {
        taskResultDao.getTaskResultById(oldTaskResult.getId());
        fail("TaskResult " + taskResult + " should not have been found");
    } catch (EmptyResultDataAccessException e) {
    }
    try {
        taskResultDao.getTaskResultById(oldTaskResult2.getId());
        fail("TaskResult " + taskResult2 + " should not have been found");
    } catch (EmptyResultDataAccessException e) {
    }
    taskResultDao.clearOld(virtualEngineID, 1);
    foundTaskResult1 = taskResultDao.getTaskResultById(taskResult.getId());
    foundTaskResult3 = taskResultDao.getTaskResultById(uniqueTaskResult.getId());
    foundTaskResult4 = taskResultDao.getTaskResultById(taskResult2.getId());
    foundTaskResult6 = taskResultDao.getTaskResultById(uniqueTaskResult2.getId());
    assertEquals(taskResult, foundTaskResult1);
    assertEquals(uniqueTaskResult, foundTaskResult3);
    assertEquals(taskResult2, foundTaskResult4);
    assertEquals(uniqueTaskResult2, foundTaskResult6);
}