Examples with Policy org.ow2.proactive.scheduler.policy.Policy used on opensource projects

Example 31 with Policy

use of org.ow2.proactive.scheduler.policy.Policy in project scheduling by ow2-proactive.

the class ListPolicyCommand method execute.

@Override
public void execute(ApplicationContext currentContext) throws CLIException {
    Map<String, PluginView> knownPolicyMap = currentContext.getPolicies();
    if (knownPolicyMap == null) {
        HttpGet request = new HttpGet(currentContext.getResourceUrl("policies"));
        HttpResponseWrapper response = execute(request, currentContext);
        if (statusCode(OK) == statusCode(response)) {
            List<PluginView> pluginViewList = readValue(response, new TypeReference<List<PluginView>>() {
            }, currentContext);
            resultStack(currentContext).push(pluginViewList.toArray(new PluginView[pluginViewList.size()]));
            knownPolicyMap = new HashMap<>();
            for (PluginView pluginView : pluginViewList) {
                knownPolicyMap.put(pluginView.getPluginName(), pluginView);
            }
            currentContext.setPolicies(knownPolicyMap);
        } else {
            handleError("An error occurred while retrieving supported policy types:", response, currentContext);
        }
    }
    if (!currentContext.isSilent()) {
        if (knownPolicyMap != null) {
            writeLine(currentContext, "%n%s:%n", "Supported policy types");
            for (PluginView policy : knownPolicyMap.values()) {
                writeLine(currentContext, "%s%n", policy.toString());
            }
        }
    }
}

Example 32 with Policy

use of org.ow2.proactive.scheduler.policy.Policy in project scheduling by ow2-proactive.

the class SchedulingMethodImpl method schedule.

/**
 * Scheduling process. For this implementation, steps are :<br>
 * <ul>
 * 	<li>Select running and pending jobs to be scheduled
 * 	<li>Get an ordered list of the selected tasks to be scheduled
 * 	<li>While returned tasks list is not empty :
 * 		<ul>
 * 			<li>Get n first compatible tasks (same selection script, same node exclusion)
 * 			<li>Ask nodes to RM according to the previous specification
 * 			<li>Try to start each tasks
 * 			<li>Job started event if needed
 * 			<li>Task started event
 * 		</ul>
 * 	<li>Manage exception while deploying tasks on nodes
 * </ul>
 *
 * @return the number of tasks that have been started
 */
public int schedule() {
    Policy currentPolicy = schedulingService.getPolicy();
    // Number of time to retry an active object creation before leaving scheduling loop
    activeObjectCreationRetryTimeNumber = ACTIVEOBJECT_CREATION_RETRY_TIME_NUMBER;
    // get job Descriptor list with eligible jobs (running and pending)
    Map<JobId, JobDescriptor> jobMap = schedulingService.lockJobsToSchedule();
    Map<JobId, JobDescriptor> toUnlock = jobMap;
    logSelectedJobs(jobMap);
    // we wait for next scheduling loop and don't start any task
    if (jobMap.isEmpty()) {
        return 0;
    }
    return startTasks(currentPolicy, jobMap, toUnlock);
}

Example 33 with Policy

use of org.ow2.proactive.scheduler.policy.Policy in project scheduling by ow2-proactive.

the class SchedulerFrontend method getTasksToSchedule.

@Override
public List<TaskDescriptor> getTasksToSchedule() throws NotConnectedException, PermissionException {
    Policy policy = null;
    List<TaskDescriptor> eligibleTasks = new ArrayList<>();
    Map<JobId, JobDescriptor> jobMap = null;
    try {
        jobMap = schedulingService.lockJobsToSchedule();
        policy = (Policy) Class.forName(getCurrentPolicy()).newInstance();
        // we wait for next scheduling loop
        if (jobMap.isEmpty()) {
            return eligibleTasks;
        }
        List<JobDescriptor> descriptors = new ArrayList<>(jobMap.values());
        LinkedList<EligibleTaskDescriptor> taskRetrievedFromPolicy = policy.getOrderedTasks(descriptors);
        // if there is no task to scheduled, return
        if (taskRetrievedFromPolicy.isEmpty()) {
            return eligibleTasks;
        }
        eligibleTasks = (List) taskRetrievedFromPolicy;
    } catch (Exception e) {
        logger.error("Error Loading Current Policy:", e);
    } finally {
        schedulingService.unlockJobsToSchedule(jobMap.values());
    }
    return eligibleTasks;
}

Example 34 with Policy

use of org.ow2.proactive.scheduler.policy.Policy in project scheduling by ow2-proactive.

the class SchedulerFrontend method initActivity.

/**
 * @see org.objectweb.proactive.InitActive#initActivity(org.objectweb.proactive.Body)
 */
@Override
public void initActivity(Body body) {
    try {
        // setting up the policy
        logger.debug("Setting up scheduler security policy");
        ClientsPolicy.init();
        // creating the scheduler authentication interface.
        // if this fails then it will not continue.
        logger.debug("Creating scheduler authentication interface...");
        authentication = PAActiveObject.newActive(SchedulerAuthentication.class, new Object[] { PAActiveObject.getStubOnThis() });
        // creating scheduler core
        DataSpaceServiceStarter dsServiceStarter = DataSpaceServiceStarter.getDataSpaceServiceStarter();
        dsServiceStarter.startNamingService();
        ExecutorService clientThreadPool = Executors.newFixedThreadPool(PASchedulerProperties.SCHEDULER_CLIENT_POOL_NBTHREAD.getValueAsInt(), new NamedThreadFactory("ClientRequestsThreadPool"));
        ExecutorService internalThreadPool = Executors.newFixedThreadPool(PASchedulerProperties.SCHEDULER_INTERNAL_POOL_NBTHREAD.getValueAsInt(), new NamedThreadFactory("InternalOperationsThreadPool"));
        ExecutorService taskPingerThreadPool = Executors.newFixedThreadPool(PASchedulerProperties.SCHEDULER_TASK_PINGER_POOL_NBTHREAD.getValueAsInt(), new NamedThreadFactory("TaskPingerThreadPool"));
        ScheduledExecutorService scheduledThreadPool = new ScheduledThreadPoolExecutor(PASchedulerProperties.SCHEDULER_SCHEDULED_POOL_NBTHREAD.getValueAsInt(), new NamedThreadFactory("SchedulingServiceTimerThread"));
        // at this point we must wait the resource manager
        RMConnection.waitAndJoin(rmURL.toString());
        RMProxiesManager rmProxiesManager = RMProxiesManager.createRMProxiesManager(rmURL);
        RMProxy rmProxy = rmProxiesManager.getRmProxy();
        long loadJobPeriod = -1;
        if (PASchedulerProperties.SCHEDULER_DB_LOAD_JOB_PERIOD.isSet()) {
            String periodStr = PASchedulerProperties.SCHEDULER_DB_LOAD_JOB_PERIOD.getValueAsString();
            if (periodStr != null && !periodStr.isEmpty()) {
                try {
                    loadJobPeriod = Tools.parsePeriod(periodStr);
                } catch (IllegalArgumentException e) {
                    logger.warn("Invalid load job period string: " + periodStr + ", this setting is ignored", e);
                }
            }
        }
        logger.debug("Booting jmx...");
        this.jmxHelper.boot(authentication);
        RecoveredSchedulerState recoveredState = new SchedulerStateRecoverHelper(dbManager).recover(loadJobPeriod, rmProxy);
        this.frontendState = new SchedulerFrontendState(recoveredState.getSchedulerState(), jmxHelper);
        SchedulingInfrastructure infrastructure = new SchedulingInfrastructureImpl(dbManager, rmProxiesManager, dsServiceStarter, clientThreadPool, internalThreadPool, taskPingerThreadPool, scheduledThreadPool);
        this.spacesSupport = infrastructure.getSpacesSupport();
        this.corePublicKey = Credentials.getPublicKey(PASchedulerProperties.getAbsolutePath(PASchedulerProperties.SCHEDULER_AUTH_PUBKEY_PATH.getValueAsString()));
        this.schedulingService = new SchedulingService(infrastructure, frontendState, recoveredState, policyFullName, null);
        recoveredState.enableLiveLogsForRunningTasks(schedulingService);
        releaseBusyNodesWithNoRunningTask(rmProxy, recoveredState);
        logger.debug("Registering scheduler...");
        PAActiveObject.registerByName(authentication, SchedulerConstants.SCHEDULER_DEFAULT_NAME);
        authentication.setActivated(true);
        Tools.logAvailableScriptEngines(logger);
        if (PASchedulerProperties.SCHEDULER_MEM_MONITORING_FREQ.isSet()) {
            logger.debug("Starting the memory monitoring process...");
            metricsMonitorScheduler = new it.sauronsoftware.cron4j.Scheduler();
            String cronExpr = PASchedulerProperties.SCHEDULER_MEM_MONITORING_FREQ.getValueAsString();
            metricsMonitorScheduler.schedule(cronExpr, new TableSizeMonitorRunner(dbManager.getTransactionHelper()));
            metricsMonitorScheduler.schedule(cronExpr, new JobsMemoryMonitorRunner(dbManager.getSessionFactory().getStatistics(), recoveredState.getSchedulerState()));
            metricsMonitorScheduler.start();
        }
    } catch (Exception e) {
        logger.error("Failed to start Scheduler", e);
        e.printStackTrace();
        System.exit(1);
    }
}