Examples with Signal org.ow2.proactive.scheduler.signal.Signal used on opensource projects

Example 1 with Signal

use of org.ow2.proactive.scheduler.signal.Signal in project scheduling by ow2-proactive.

the class SignalApiTest method testReadyForSignalWithVariables.

@Test
public void testReadyForSignalWithVariables() throws SignalApiException, InvalidChannelException {
    String signalName = "test_signal_1";
    JobVariable jobVariable1 = new JobVariable("name1", "value1");
    JobVariable jobVariable2 = new JobVariable("name2", "value2");
    List<JobVariable> jobVariables = new ArrayList<>();
    jobVariables.add(jobVariable1);
    jobVariables.add(jobVariable2);
    signalApi.readyForSignal(signalName, jobVariables);
    Assert.assertTrue(((Signal) synchronizationInternal.get(USER, TASK_ID, SIGNALS_CHANNEL + JOB_ID.value(), READY_PREFIX + signalName)).getName().equals(signalName));
    Assert.assertNotNull((synchronizationInternal.get(USER, TASK_ID, SIGNALS_CHANNEL + JOB_ID.value(), READY_PREFIX + signalName)));
    Assert.assertEquals(jobVariables, ((Signal) synchronizationInternal.get(USER, TASK_ID, SIGNALS_CHANNEL + JOB_ID.value(), READY_PREFIX + signalName)).getInputVariables());
}

Example 2 with Signal

use of org.ow2.proactive.scheduler.signal.Signal in project scheduling by ow2-proactive.

the class SchedulerFrontend method insertJobSignals.

private JobInfo insertJobSignals(JobInfo jobInfo) {
    String jobid = jobInfo.getJobId().value();
    if (checkJobPermissionMethod(jobid, "addJobSignal")) {
        try {
            TaskId taskId = createFakeTaskId(jobInfo.getJobId().value());
            if (publicStore.channelExists(SIGNAL_ORIGINATOR, taskId, signalsChannel + jobid)) {
                Set<Map.Entry<String, Serializable>> signalEntries = publicStore.entrySet(SIGNAL_ORIGINATOR, taskId, signalsChannel + jobid);
                Set<String> signalsToBeAdded = signalEntries.stream().map(entry -> entry.getKey()).collect(Collectors.toSet());
                List<Signal> signalList = signalEntries.stream().map(entry -> (Signal) entry.getValue()).collect(Collectors.toList());
                Map<String, Map<String, JobVariable>> detailedSignalsToBeAdded = new LinkedHashMap<>();
                signalList.forEach(signal -> {
                    Map<String, JobVariable> variableMap = new LinkedHashMap<>();
                    if (signal.getInputVariables() != null) {
                        signal.getInputVariables().forEach(jobVariable -> variableMap.put(jobVariable.getName(), jobVariable));
                    }
                    detailedSignalsToBeAdded.put(signal.getName(), variableMap);
                });
                Set<String> jobSignals = jobInfo.getSignals();
                Map<String, Map<String, JobVariable>> jobDetailedSignals = jobInfo.getDetailedSignals();
                if (signalsToBeAdded != null && !signalsToBeAdded.isEmpty()) {
                    jobSignals.addAll(signalsToBeAdded);
                    jobInfo.setSignals(jobSignals);
                }
                if (detailedSignalsToBeAdded != null && !detailedSignalsToBeAdded.isEmpty()) {
                    jobDetailedSignals.putAll(detailedSignalsToBeAdded);
                    jobInfo.setDetailedSignals(jobDetailedSignals);
                }
            }
        } catch (InvalidChannelException e) {
            logger.warn("Could not retrieve the signals of the job " + jobid);
        }
    }
    return jobInfo;
}

Example 3 with Signal

use of org.ow2.proactive.scheduler.signal.Signal in project scheduling by ow2-proactive.

the class SchedulerClientTest method testSignals.

@Test(timeout = MAX_WAIT_TIME)
public void testSignals() throws Throwable {
    ISchedulerClient client = clientInstance();
    Job job = nodeClientJob("/functionaltests/descriptors/register_service_with_signals.groovy", null, null);
    // submit job with 'ready signal' and add variables
    JobId jobId = submitJob(job, client);
    JobInfo jobInfo;
    // wait until 'ready_my_signal' signal is sent
    do {
        jobInfo = client.getJobInfo(jobId.toString());
        Assert.assertNotNull(jobInfo);
        Thread.sleep(1000);
    } while (!jobInfo.getSignals().contains("ready_my_signal"));
    Map<String, String> outpuVariables = new HashMap<>();
    outpuVariables.put("name", "15");
    // validate the job variables
    List<JobVariable> jobVariables = client.validateJobSignal(jobId.value(), "my_signal", outpuVariables);
    // add 'my_signal' signal
    Set<String> signals = client.addJobSignal(jobId.value(), "my_signal", outpuVariables);
    // wait until the job is finished
    client.waitForJob(jobId.toString(), TimeUnit.MINUTES.toMillis(5));
    Assert.assertFalse(signals.contains("ready_my_signal"));
    Assert.assertTrue(signals.contains("my_signal"));
    JobVariable nameJobVariable = jobVariables.stream().filter(jobVariable -> jobVariable.getName().equals("name")).findFirst().get();
    Assert.assertNotNull(nameJobVariable);
    Assert.assertEquals("15", nameJobVariable.getValue());
    Assert.assertEquals("PA:Integer", nameJobVariable.getModel());
    JobVariable secondJobVariable = jobVariables.stream().filter(jobVariable -> jobVariable.getName().equals("second")).findFirst().get();
    Assert.assertNotNull(secondJobVariable);
    Assert.assertEquals("15", secondJobVariable.getValue());
    Assert.assertEquals("PA:Integer", secondJobVariable.getModel());
}

Example 4 with Signal

use of org.ow2.proactive.scheduler.signal.Signal in project scheduling by ow2-proactive.

the class SignalApiTest method classInit.

@BeforeClass
public static void classInit() throws IOException, ActiveObjectCreationException, NodeException, AlreadyBoundException {
    CentralPAPropertyRepository.PA_CLASSLOADING_USEHTTP.setValue(false);
    if (System.getProperty("log4j.configuration") == null) {
        // While logger is not configured and it not set with sys properties, use Console logger
        Logger.getRootLogger().getLoggerRepository().resetConfiguration();
        BasicConfigurator.configure(new ConsoleAppender(new PatternLayout("%m%n")));
        Logger.getRootLogger().setLevel(Level.DEBUG);
    }
    Logger.getLogger(SignalApiImpl.class).setLevel(Level.TRACE);
    tempFolder = folder.newFolder("signal");
    Node localNode = ProActiveRuntimeImpl.getProActiveRuntime().createLocalNode("signal-node-0", true, "signal-v-node-0");
    synchronizationInternal = PAActiveObject.newActive(AOSynchronization.class, new Object[] { tempFolder.getAbsolutePath() }, localNode);
    synchronizationInternal.createChannelIfAbsent(USER, TASK_ID, SIGNALS_CHANNEL, true);
    signalApi = new SignalApiImpl(USER, TASK_ID, synchronizationInternal);
    executor = Executors.newFixedThreadPool(2);
}

Example 5 with Signal

use of org.ow2.proactive.scheduler.signal.Signal in project scheduling by ow2-proactive.

the class SSHInfrastructureV2 method startNodeImpl.

/**
 * Internal node acquisition method
 * <p>
 * Starts a PA runtime on remote host using SSH, register it manually in the
 * nodesource.
 *
 * @param hostTracker The host on which one the node will be started
 * @param nbNodes number of nodes to deploy
 * @param depNodeURLs list of deploying or lost nodes urls created
 * @throws RMException
 *             acquisition failed
 */
public void startNodeImpl(final HostTracker hostTracker, final int nbNodes, final List<String> depNodeURLs) throws RMException {
    String fs = getTargetOSObj().fs;
    // we set the java security policy file
    ArrayList<String> sb = new ArrayList<>();
    final boolean containsSpace = schedulingPath.contains(" ");
    if (!deploymentMode.equals("useNodeJarStartupScript")) {
        if (containsSpace) {
            sb.add("-Dproactive.home=\"" + schedulingPath + "\"");
        } else {
            sb.add("-Dproactive.home=" + schedulingPath);
        }
    }
    String securitycmd = CentralPAPropertyRepository.JAVA_SECURITY_POLICY.getCmdLine();
    if (!this.javaOptions.contains(securitycmd) && !deploymentMode.equals("useNodeJarStartupScript")) {
        if (containsSpace) {
            securitycmd += "\"";
        }
        securitycmd += this.schedulingPath + fs + "config" + fs;
        securitycmd += "security.java.policy-client";
        if (containsSpace) {
            securitycmd += "\"";
        }
        sb.add(securitycmd);
    }
    // we set the log4j configuration file
    String log4jcmd = CentralPAPropertyRepository.LOG4J.getCmdLine();
    if (!this.javaOptions.contains(log4jcmd) && !deploymentMode.equals("useNodeJarStartupScript")) {
        // log4j only understands urls
        if (containsSpace) {
            log4jcmd += "\"";
        }
        log4jcmd += "file:";
        if (!this.schedulingPath.startsWith("/")) {
            log4jcmd += "/";
        }
        log4jcmd += this.schedulingPath.replace("\\", "/");
        log4jcmd += "/config/log/node.properties";
        if (containsSpace) {
            log4jcmd += "\"";
        }
        sb.add(log4jcmd);
    }
    // we add extra java/PA configuration
    if (this.javaOptions != null && !this.javaOptions.trim().isEmpty()) {
        sb.add(this.javaOptions.trim());
    }
    CommandLineBuilder clb = super.getDefaultCommandLineBuilder(getTargetOSObj());
    final boolean deployNodesInDetachedMode = PAResourceManagerProperties.RM_NODES_RECOVERY.getValueAsBoolean() || PAResourceManagerProperties.RM_PRESERVE_NODES_ON_SHUTDOWN.getValueAsBoolean();
    if (deployNodesInDetachedMode) {
        // if we do not want to kill the nodes when the RM exits or
        // restarts, then we should launch the nodes in background and
        // ignore the RM termination signal
        clb.setDetached();
    }
    clb.setJavaPath(this.javaPath);
    clb.setRmHome(this.schedulingPath);
    clb.setPaProperties(sb);
    final String nodeName = nodeNameBuilder.generateNodeName(hostTracker);
    clb.setNodeName(nodeName);
    clb.setNumberOfNodes(nbNodes);
    // set the stratup script retrieved from NodeCommandLine.properties
    if (!this.deploymentMode.equals("autoGenerated")) {
        clb.setDeploymentMode(deploymentMode);
        clb.setStartupScript((deploymentMode.equals("useStartupScript") ? startupScriptStandard : startupScriptWithNodeJarDownload));
    }
    if (this.deploymentMode.equals("useNodeJarStartupScript")) {
        clb.setNodeJarUrl(nodeJarUrl);
    }
    // finally, the credential's value
    String credString;
    try {
        Client currentClient = super.nodeSource.getAdministrator();
        credString = new String(currentClient.getCredentials().getBase64());
    } catch (KeyException e) {
        throw new RMException("Could not get base64 credentials", e);
    }
    clb.setCredentialsValueAndNullOthers(credString);
    // add an expected node. every unexpected node will be discarded
    String cmdLine;
    String obfuscatedCmdLine;
    try {
        cmdLine = clb.buildCommandLine(true);
        obfuscatedCmdLine = clb.buildCommandLine(false);
    } catch (IOException e) {
        throw new RMException("Cannot build the " + RMNodeStarter.class.getSimpleName() + "'s command line.", e);
    }
    // one escape the command to make it runnable through ssh
    if (cmdLine.contains("\"")) {
        cmdLine = cmdLine.replaceAll("\"", "\\\\\"");
    }
    final String finalCmdLine = cmdLine;
    // The final addDeployingNode() method will initiate a timeout that
    // will declare node as lost and set the description of the failure
    // with a simplistic message, since there is no way to override this
    // mechanism we consider only 90% of timeout to set custom description
    // in case of failure and still allow global timeout
    final int shorterTimeout = Math.round((90 * super.nodeTimeOut) / 100);
    JSch jsch = new JSch();
    final String msg = "deploy on " + hostTracker.getResolvedAddress();
    final List<String> createdNodeNames = RMNodeStarter.getWorkersNodeNames(nodeName, nbNodes);
    depNodeURLs.addAll(addMultipleDeployingNodes(createdNodeNames, obfuscatedCmdLine, msg, super.nodeTimeOut));
    addTimeouts(depNodeURLs);
    Session session;
    try {
        // Create ssh session to the hostname
        session = jsch.getSession(this.sshUsername, hostTracker.getResolvedAddress().getHostName(), this.sshPort);
        if (this.sshPassword == null) {
            jsch.addIdentity(this.sshUsername, this.sshPrivateKey, null, null);
        } else {
            session.setPassword(this.sshPassword);
        }
        session.setConfig(this.sshOptions);
        session.connect(shorterTimeout);
    } catch (JSchException e) {
        multipleDeclareDeployingNodeLost(depNodeURLs, "unable to " + msg + "\n" + getStackTraceAsString(e));
        throw new RMException("unable to " + msg, e);
    }
    SSHInfrastructureV2.logger.info("Executing SSH command: '" + finalCmdLine + "'");
    ScheduledExecutorService deployService = Executors.newSingleThreadScheduledExecutor();
    try {
        // Create ssh channel to run the cmd
        ByteArrayOutputStream baos = new ByteArrayOutputStream(DEFAULT_OUTPUT_BUFFER_LENGTH);
        ChannelExec channel;
        try {
            channel = (ChannelExec) session.openChannel("exec");
            channel.setCommand(finalCmdLine);
            channel.setOutputStream(baos);
            channel.setErrStream(baos);
            channel.connect();
        } catch (JSchException e) {
            multipleDeclareDeployingNodeLost(depNodeURLs, "unable to " + msg + "\n" + getStackTraceAsString(e));
            throw new RMException("unable to " + msg, e);
        }
        final ChannelExec chan = channel;
        Future<Void> deployResult = deployService.submit(new Callable<Void>() {

            @Override
            public Void call() throws Exception {
                while (!shutDown.get() && !checkAllNodesAreAcquiredAndDo(createdNodeNames, null, null)) {
                    if (anyTimedOut(depNodeURLs)) {
                        throw new IllegalStateException("The upper infrastructure has issued a timeout");
                    }
                    // processes live completely independently
                    if (!deployNodesInDetachedMode && chan.getExitStatus() != PROCESS_STILL_RUNNING_VALUE) {
                        throw new IllegalStateException("The jvm process of the node has exited prematurely");
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // we know the cause of this
                        return null;
                    // interruption just exit
                    }
                }
                // Victory
                return null;
            }
        });
        try {
            deployResult.get(shorterTimeout, TimeUnit.MILLISECONDS);
        } catch (ExecutionException e) {
            declareLostAndThrow("Unable to " + msg + " due to " + e.getCause(), depNodeURLs, channel, baos, e);
        } catch (InterruptedException e) {
            deployResult.cancel(true);
            declareLostAndThrow("Unable to " + msg + " due to an interruption", depNodeURLs, channel, baos, e);
        } catch (TimeoutException e) {
            deployResult.cancel(true);
            declareLostAndThrow("Unable to " + msg + " due to timeout", depNodeURLs, channel, baos, e);
        } finally {
            channel.disconnect();
        }
    } finally {
        removeTimeouts(depNodeURLs);
        session.disconnect();
        deployService.shutdownNow();
    }
}