Beispiel #1
0
/**
 * SSH Job: Callback function called when a line is read from standard error
 */
void
ngisSSHjobErrorCallback(
    void *arg,
    ngisLineBuffer_t *lineBuffer,
    char *line,
    ngisCallbackResult_t cResult)
{
    ngisSSHjob_t *job = arg;
    int result;
    ngisLog_t *log = NULL;
    static const char fName[] = "ngisSSHjobErrorCallback";

    NGIS_ASSERT(job != NULL);
    NGIS_ASSERT(lineBuffer != NULL);
    NGIS_ASSERT(lineBuffer == job->ngsj_lBufStderr);

    log = job->ngsj_log;

    switch (cResult) {
    case NGIS_CALLBACK_RESULT_EOF:
        ngisDebugPrint(log, fName, "Called with EOF.\n");
        goto error;
    case NGIS_CALLBACK_RESULT_CANCEL:
        ngisDebugPrint(log, fName, "Called because callback was canceled.\n");
        return;
    case NGIS_CALLBACK_RESULT_FAILED:
        ngisErrorPrint(log, fName,
            "Called because error occurred on reading from STDERR.\n");
        goto error;
    case NGIS_CALLBACK_RESULT_SUCCESS:
        break;
    default:
        NGIS_ASSERT_NOTREACHED();
    }
    NGIS_ASSERT(line != NULL);
    ngisErrorPrint(log, fName, "\"%s\".\n", line);

    /* Next Line */
    result = ngisLineBufferReadLine(lineBuffer, ngisSSHjobErrorCallback, job);
    if (result == 0) {
        ngisErrorPrint(log, fName,
            "Can't register callback for reading STDERR.\n");
        goto error;
    }
    
    return;
error:
    ngisLineBufferDestroy(job->ngsj_lBufStderr);
    job->ngsj_lBufStderr = NULL;

    return;
}
Beispiel #2
0
static int
ngislSSHjobPBSwriteScript(
    ngisSSHjob_t *job,
    FILE *fp)
{
    ngisSSHjobAttributes_t *attr = NULL;
    int result;
    ngisLog_t *log = NULL;
    static const char fName[] = "ngislSSHjobPBSwriteScript";

    NGIS_ASSERT(job != NULL);
    NGIS_ASSERT(fp != NULL);

    attr = job->ngsj_attributes;
    log = job->ngsj_log;

    result = ngislSSHjobPBSwriteScriptHeader(job, fp);
    if (result == 0) {
        ngisErrorPrint(log, fName, "Can't write script header.\n");
        return 0;
    }

    switch (attr->ngsja_jobBackend) {
    case NGIS_BACKEND_NORMAL:
        if (attr->ngsja_count > 1) {
            result = ngisSSHjobWriteArrayJobCommandToScript(
                job, fp, NGISL_PBS_NODEFILE, attr->ngsja_sshPBSrsh);
        } else {
            result = ngisSSHjobWriteSingleJobCommandToScript(job, fp);
        }
        break;
    case NGIS_BACKEND_MPI:
    case NGIS_BACKEND_BLACS:
        result = ngisSSHjobWriteMPICommandToScript(
            job, fp, NGISL_PBS_NODEFILE);
        break;
    default:
        result = 0;
        NGIS_ASSERT_NOTREACHED();
    }
    if (result < 0) {
        ngisErrorPrint(log, fName, "Can't print command string.\n");
        return 0;
    }

    return 1;
}
Beispiel #3
0
static int
ngislSSHjobPBSwriteResource(
    ngisSSHjob_t *job,
    FILE *fp)
{
    ngisSSHjobAttributes_t *attr;
    int ppn;
    int count;
    int fraction;
    int nNodes;
    int result = -1;
    static const char fName[] = "ngislSSHjobPBSwriteResource";

    NGIS_ASSERT(job != NULL);
    NGIS_ASSERT(fp != NULL);

    attr = job->ngsj_attributes;

    ppn      = attr->ngsja_sshPBSprocessorsPerNode;
    count    = attr->ngsja_count;
    fraction = count%ppn;
    nNodes   = count/ppn;

    if ((nNodes > 0) && (fraction > 0)) {
        result = fprintf(fp, "#PBS -l nodes=%d:ppn=%d+nodes=1:ppn=%d\n",
            nNodes, ppn, fraction);
    } else if (nNodes > 0) {
        result = fprintf(fp, "#PBS -l nodes=%d:ppn=%d\n",
            nNodes, ppn);
    } else if (fraction > 0) {
        result = fprintf(fp, "#PBS -l nodes=1:ppn=%d\n",
            fraction);
    } else {
        NGIS_ASSERT_NOTREACHED();
    }
    if (result < 0) {
        ngisErrorPrint(job->ngsj_log, fName,
            "Can't print number of executable to scriptfile.\n");
        return 0;
    }
    return 1;
}
Beispiel #4
0
static void
ngislSSHjobPBSqueryStatusReadCallback(
    void *arg,
    ngisLineBuffer_t *lBuf,
    char *line,
    ngisCallbackResult_t cResult)
{
    ngisSSHjob_t *job = arg;
    int result;
    int i;
    ngisTokenAnalyzer_t tokenAnalyzer;
    int tokenAnalyzerInitialized = 0;
    char *status = NULL;
    ngisLog_t *log;
    static const char fName[] = "ngislSSHjobPBSqueryStatusReadCallback";

    NGIS_ASSERT(job != NULL);
    NGIS_ASSERT(lBuf != NULL);

    log = job->ngsj_log;

    switch (cResult) {
    case NGIS_CALLBACK_RESULT_EOF:
        ngisErrorPrint(log, fName, "Unexcept EOF.\n");
        goto error;
    case NGIS_CALLBACK_RESULT_CANCEL:
        ngisDebugPrint(log, fName,
            "Callback is canceled.\n");
        return;
    case NGIS_CALLBACK_RESULT_FAILED:
        ngisErrorPrint(log, fName,
            "Can't read the reply.\n");
        goto error;
    case NGIS_CALLBACK_RESULT_SUCCESS:
        break;
    default:
        NGIS_ASSERT_NOTREACHED();
    }

    /* Failed? */
    if (strcmp(line, "dummy") == 0) {
        /* Done */
        job->ngsj_executables[0].nge_exitCode = 0;/* Success */
        result = ngisSSHjobExecutableSetStatus(
            job, &job->ngsj_executables[0],
            NGIS_EXECUTABLE_STATUS_EXIT);
        if (result == 0) {
            ngisErrorPrint(log, fName,
                "Can't set status.\n");            
            goto error;
        }

        result = ngisSSHjobProcessAfterExit(job);
        if (result == 0) {
            ngisErrorPrint(log, fName,
                "Can't process after exit.\n");
            goto error;
        }
        return;
    }

    ngisTokenAnalyzerInitialize(&tokenAnalyzer, line);
    tokenAnalyzerInitialized = 0;

    /* job_state = [STATUS] */
    for (i = 0;i < 2;++i) {
        result = ngisTokenAnalyzerNext(&tokenAnalyzer);
        if (result == 0) {
            ngisErrorPrint(log, fName,
                "Can't get status.\n.");
            goto error;
        }
    }
    
    /* Get Status */
    status = ngisTokenAnalyzerGetString(&tokenAnalyzer);
    if (status == NULL) {
        ngisErrorPrint(log, fName,
            "Can't get status.\n");
        goto error;
    }

    ngisDebugPrint(log, fName, "Status string is \"%s\".\n", status);

    /* Check Status */
    switch (*status) {
    case 'Q':
    case 'W':
    case 'T':
        break;
    case 'B':
    case 'E':
    case 'R':
    case 'X':
        /* t(ransfering), r(unning) */
        job->ngsj_executables[0].nge_status
            = NGIS_EXECUTABLE_STATUS_ACTIVE;
        break;
    case 'H':
        /* Do nothing */
        break;
    case 'S':
        break;
    case 'U':
    default:
        /* DONOTHING */;
    }

    free(status);
    status = NULL;

    ngisTokenAnalyzerFinalize(&tokenAnalyzer);
    tokenAnalyzerInitialized = 0;

    result = ngisLineBufferReadLine(job->ngsj_lBufStdout, 
        ngisSSHjobQueryStatusReadDummyCallback, job);
    if (result == 0) {
        ngisErrorPrint(log, fName, 
            "Can't register the function for reading the line.\n");
        goto error;
    }

    return;
error:
    NGIS_NULL_CHECK_AND_FREE(status);

    if (tokenAnalyzerInitialized != 0) {
        ngisTokenAnalyzerFinalize(&tokenAnalyzer);
        tokenAnalyzerInitialized = 0;
    }
    result = ngisSSHjobProcessAfterExit(job);
    if (result == 0) {
        ngisErrorPrint(NULL, fName, "The job isn't able to be done.\n");
    }
    return;
}
Beispiel #5
0
static void
ngislSSHjobPBSsubmitReadCallback(
    void *arg,
    ngisLineBuffer_t *lBuf,
    char *line,
    ngisCallbackResult_t cResult)
{
    ngisSSHjob_t *job = arg;
    int result;
    char *jobID = NULL;
    int nActive;
    ngisLog_t *log;
    static const char fName[] = "ngislSSHjobPBSsubmitReadCallback";

    NGIS_ASSERT(job != NULL);
    NGIS_ASSERT(lBuf != NULL);

    log = job->ngsj_log;

    switch (cResult) {
    case NGIS_CALLBACK_RESULT_CANCEL:
        ngisDebugPrint(log, fName, "Callback is canceled.\n");
        return;
    case NGIS_CALLBACK_RESULT_EOF:
        ngisErrorPrint(log, fName, "Unexcept EOF.\n");
        goto error;
    case NGIS_CALLBACK_RESULT_FAILED:
        ngisErrorPrint(log, fName, "Can't read the reply.\n");
        goto error;
    case NGIS_CALLBACK_RESULT_SUCCESS:
        break;
    default:
        NGIS_ASSERT_NOTREACHED();
    }

    /* Failed? */
    if (strcmp(line, NGIS_SSH_JOB_COMMAND_FAILED) == 0) {
        ngisErrorPrint(log, fName, "Can't submit the job.\n");
        goto next;
    }

    ngisDebugPrint(log, fName, "Job ID = %s.\n", line);

    jobID = strdup(line);
    if (jobID == NULL) {
        ngisErrorPrint(log, fName, "Can't copy the job ID.\n");
        goto next;
    }

next:
    if (jobID != NULL) {
        job->ngsj_executables[job->ngsj_iExecutables].nge_identifier = jobID;
        jobID = NULL;
        result = ngisSSHjobExecutableSetStatus(
            job, &job->ngsj_executables[job->ngsj_iExecutables],
            NGIS_EXECUTABLE_STATUS_PENDING);
        if (result == 0) {
            ngisErrorPrint(log, fName, "Can't set status.\n");
            goto next;
        }
    } else {
        result = ngisSSHjobExecutableSetStatus(
            job, &job->ngsj_executables[job->ngsj_iExecutables],
            NGIS_EXECUTABLE_STATUS_FAILED);
        if (result == 0) {
            ngisErrorPrint(log, fName, "Can't set status.\n");
        }
    }

    job->ngsj_iExecutables++;
    if (job->ngsj_iExecutables < job->ngsj_nExecutables) {
        result = ngislSSHjobPBSsubmit(job);
        if (result == 0) {
            ngisErrorPrint(log, fName, "Can't submit next job.\n");
            goto error;
        }
    } else {
        nActive = ngisSSHjobGetNexecutable(job, NGIS_EXECUTABLE_STATUS_PENDING);
        if (nActive == 0) {
            ngisErrorPrint(log, fName, "Can't execute all executables.\n");
            goto error;
        }

        /* Polling Start */
        result = ngisSSHjobPollingStart(job);
        if (result == 0) {
            ngisErrorPrint(log, fName, "Can't start status polling.\n");
            goto error;
        }
    }    

    return;
error:
    NGIS_NULL_CHECK_AND_FREE(jobID);

    result = ngisSSHjobProcessAfterExit(job);
    if (result == 0) {
        ngisErrorPrint(NULL, fName,
            "The job isn't able to be done.\n");
    }
    return;
}
Beispiel #6
0
/**
 * SSH job: Callback function for "Query exit status"
 */
static void
ngislSSHjobExecutableDoneReadCallback(
    void *arg,
    ngisLineBuffer_t *lBuf,
    char *line,
    ngisCallbackResult_t cResult)
{
    ngisSSHjob_t *job = arg;
    int exitStatus;
    int result;
    int nExit;
    ngisLog_t *log;
    ngisTokenAnalyzer_t tokenAnalyzer;
    int tokenAnalyzerInitialized = 0;
    ngisExecutable_t *exe = NULL;
    static const char fName[] = "ngislSSHjobExecutableDoneReadCallback";

    NGIS_ASSERT(job != NULL);
    NGIS_ASSERT(lBuf != NULL);
    
    log = job->ngsj_log;

    ngisDebugPrint(log, fName, "Called.\n");

    switch (cResult) {
    case NGIS_CALLBACK_RESULT_EOF:
        ngisErrorPrint(log, fName, "Unexcept EOF.\n");
        goto error;
    case NGIS_CALLBACK_RESULT_CANCEL:
        ngisDebugPrint(log, fName, "Callback is canceled.\n");
        return;
    case NGIS_CALLBACK_RESULT_FAILED:
        ngisDebugPrint(log, fName, "Can't read the reply.\n");
        goto error;
    case NGIS_CALLBACK_RESULT_SUCCESS:
        break;
    default:
        NGIS_ASSERT_NOTREACHED();
    }

    NGIS_ASSERT(line != NULL);

    ngisTokenAnalyzerInitialize(&tokenAnalyzer, line);
    tokenAnalyzerInitialized = 1;

    /* Get Exit Status */
    result = ngisTokenAnalyzerGetInt(&tokenAnalyzer, &exitStatus);
    if (result == 0) {
        ngisErrorPrint(log, fName, "Can't get exit status.\n");
        goto error;
    }

    /* Check End */
    result = ngisTokenAnalyzerNext(&tokenAnalyzer);
    if (result != 0) {
        ngisErrorPrint(log, fName, "Unnecessary token.\n.");
        goto error;
    }
    tokenAnalyzerInitialized = 0;
    ngisTokenAnalyzerFinalize(&tokenAnalyzer);

    ngisDebugPrint(log, fName, "Exit status is \"%d\".\n", exitStatus);

    /* Set status */
    exe = &job->ngsj_executables[job->ngsj_iExecutables];
    exe->nge_exitCode = exitStatus;
    result = ngisSSHjobExecutableSetStatus(
        job, exe, NGIS_EXECUTABLE_STATUS_EXIT);
    if (result == 0) {
        ngisErrorPrint(log, fName, "Can't set status.\n");
        goto error;
    }

    nExit = ngisSSHjobGetNexecutable(job, NGIS_EXECUTABLE_STATUS_EXIT);
    if (nExit >= job->ngsj_nExecutables) {
        ngisDebugPrint(log, fName, "All Executable exit.\n");
        result = ngisSSHjobProcessAfterExit(job);
        if (result == 0) {
            ngisErrorPrint(log, fName, "Can't process after exit.\n");
            goto error;
        }
    } else {
        ngisDebugPrint(log, fName, "Check status of the next executable.\n");
        job->ngsj_iExecutables++;
        result = ngislSSHjobQueryStatus(job);
        if (result == 0) {
            ngisErrorPrint(log, fName, "Can't query status.\n");
            goto error;
        }
    }
    return;

error:
    if (tokenAnalyzerInitialized != 0) {
        tokenAnalyzerInitialized = 0;
        ngisTokenAnalyzerFinalize(&tokenAnalyzer);
    }

    result = ngisSSHjobProcessAfterExit(job);
    if (result == 0) {
        ngisErrorPrint(NULL, fName,
            "The job isn't able to be done.\n");
    }
    return;
}
Beispiel #7
0
static void
ngislSSHjobQueryStatusReadCallback(
    void *arg,
    ngisLineBuffer_t *lBuf,
    char *line,
    ngisCallbackResult_t cResult)
{
    ngisSSHjob_t *job = arg;
    ngisCallback_t callback;
    int result;
    char *command;
    ngisLog_t *log;
    static const char fName[] = "ngislSSHjobQueryStatusReadCallback";

    NGIS_ASSERT(job != NULL);
    NGIS_ASSERT(lBuf != NULL);

    log = job->ngsj_log;

    ngisDebugPrint(log, fName, "Called.\n");

    switch (cResult) {
    case NGIS_CALLBACK_RESULT_EOF:
        ngisErrorPrint(log, fName, "Unexcept EOF.\n");
        goto error;
    case NGIS_CALLBACK_RESULT_CANCEL:
        ngisDebugPrint(log, fName, "Callback is canceled.\n");
        return;
    case NGIS_CALLBACK_RESULT_FAILED:
        ngisDebugPrint(log, fName, "Can't read the data.\n");
        goto error;
    case NGIS_CALLBACK_RESULT_SUCCESS:
        break;
    default:
        NGIS_ASSERT_NOTREACHED();
    }

    if (strcmp(line, NGIS_SSH_JOB_NONE) == 0) {
        /* Check next executable */
        job->ngsj_iExecutables++;
        result = ngislSSHjobQueryStatus(job);
        if (result == 0) {
            ngisErrorPrint(log, fName, "Can't query the status.\n");
            goto error;
        }
    } else if (strcmp(line, NGIS_SSH_JOB_EXIT) == 0) {
        /* Wait the child process and get exit status */
        job->ngsj_nextReadCallback = ngislSSHjobExecutableDoneReadCallback;
        callback = ngisCallbackWriteFormat(
            job->ngsj_stdio.ngsio_in, ngisSSHjobWriteStringCallback, job,
            "wait %s;%s $?\n",
            job->ngsj_executables[job->ngsj_iExecutables].nge_identifier,
            NGIS_ECHO_COMMAND);
        if (!ngisCallbackIsValid(callback)) {
            ngisErrorPrint(log, fName, 
                "Can't write command getting exit code.\n");
            goto error;
        }
        command = NULL;
    } else {
        NGIS_ASSERT_NOTREACHED();
    }

    return;

error:
    result = ngisSSHjobProcessAfterExit(job);
    if (result == 0) {
        ngisErrorPrint(NULL, fName,
            "The job isn't able to be done.\n");
    }
    return;
}
Beispiel #8
0
/**
 * SSH job: Callback for polling
 */
void
ngisSSHjobPollingCallback(
    void *arg,
    ngisCallbackResult_t cResult)
{
    ngisSSHjob_t *job = arg;
    int result;
    ngisLog_t *log;
    static const char fName[] = "ngisSSHjobPollingCallback";

    NGIS_ASSERT(job != NULL);

    log = job->ngsj_log;
    job->ngsj_timerCallback = NULL;

    ngisDebugPrint(log, fName, "Called.\n");

    switch (cResult) {
    case NGIS_CALLBACK_RESULT_SUCCESS:
        break;
    case NGIS_CALLBACK_RESULT_CANCEL:
        ngisDebugPrint(log, fName, "Canceled.\n");
        return;
    case NGIS_CALLBACK_RESULT_FAILED:
        ngisErrorPrint(log, fName, "Failed.\n");
        goto error;
    default:
        NGIS_ASSERT_NOTREACHED();
    }

    /* Next */
    result = ngisSSHjobPollingStart(job);
    if (result == 0) {
        ngisErrorPrint(log, fName, "Can't continue status polling.\n");
        goto error;
    }

    if (job->ngsj_statusChecking != 0) {
        ngisWarningPrint(log, fName, 
            "Previous status checking still has not finished. "
            "Skip checking of this time.\n");
        /* DONOTHING */
        return;
    } else {
        /* Check Start */
        ngisSSHjobFunctionReset(job);
        job->ngsj_statusChecking = 1;
        job->ngsj_iExecutables = 0;
        switch (job->ngsj_jobManagerType) {
        case NGIS_SSH_JOB_MANAGER_NORMAL:
            result = ngislSSHjobQueryStatus(job);
            break;
        case NGIS_SSH_JOB_MANAGER_SGE:
            result = ngisSSHjobSGEqueryStatus(job);
            break;
        case NGIS_SSH_JOB_MANAGER_PBS:
            result = ngisSSHjobPBSqueryStatus(job);
            break;
        default:
            NGIS_ASSERT_NOTREACHED();
        }
        if (result == 0) {
            ngisErrorPrint(log, fName, "Can't query status.\n");
            goto error;
        }
    }
    
    return;
error:
    result = ngisSSHjobProcessAfterExit(job);
    if (result == 0) {
        ngisErrorPrint(NULL, fName, "The job isn't able to be done.\n");
    }
    return;
}
Beispiel #9
0
/**
 * SSH Job: Cancel
 */
static int
ngislSSHjobCancel(
    ngisJob_t* job)
{
    ngisSSHjob_t *sshJob = (ngisSSHjob_t *)job;
    int result = 0;
    ngisExecutableStatus_t status;
    ngisLog_t *log;
    static const char fName[] = "ngislSSHjobCancel";    

    NGIS_ASSERT(sshJob != NULL);

    log = sshJob->ngsj_log;
    
    ngisDebugPrint(log, fName, "called.\n");
    sshJob->ngsj_cancelCalled = 0;

    status = ngisSSHjobGetStatus(sshJob);
    switch (status) {
    case NGIS_EXECUTABLE_STATUS_UNSUBMITTED:
        result = ngisSSHjobDone(sshJob);
        if (result == 0) {
            ngisErrorPrint(NULL, fName,
                "The job isn't able to be done.\n");
        }
        break;
    case NGIS_EXECUTABLE_STATUS_SUBMITTING:
        ngisDebugPrint(log, fName, "Delayed cancel.\n");
        sshJob->ngsj_cancelCalled = 1;
        break;
    case NGIS_EXECUTABLE_STATUS_PENDING:
    case NGIS_EXECUTABLE_STATUS_ACTIVE:
        if (sshJob->ngsj_statusChecking == 0) {
            switch (sshJob->ngsj_jobManagerType) {
            case NGIS_SSH_JOB_MANAGER_NORMAL:
                result = ngislSSHjobDoCancel(sshJob);
                break;
            case NGIS_SSH_JOB_MANAGER_SGE:
                result = ngisSSHjobSGEdoCancel(sshJob);
                break;
            case NGIS_SSH_JOB_MANAGER_PBS:
                result = ngisSSHjobPBSdoCancel(sshJob);
                break;
            default:
                NGIS_ASSERT_NOTREACHED();
            }
            if (result == 0) {
                ngisErrorPrint(log, fName, "Can't cancel the job.\n");
                return 0;
            }
        } else {
            ngisDebugPrint(log, fName, "Delayed cancel.\n");
            sshJob->ngsj_cancelCalled = 1;
        }
        break;
    case NGIS_EXECUTABLE_STATUS_DONE:
    case NGIS_EXECUTABLE_STATUS_FAILED:
    case NGIS_EXECUTABLE_STATUS_STAGEOUT:
    case NGIS_EXECUTABLE_STATUS_FAILED_STAGEOUT:
    case NGIS_EXECUTABLE_STATUS_EXIT:
        break;
    }

    return 1; 
}
Beispiel #10
0
/**
 * SSH Job: Initialize
 */
static int
ngislSSHjobInitialize(
    ngisJob_t *job,
    ngisOptionContainer_t *opts)
{
    ngisSSHjob_t *sshJob = (ngisSSHjob_t *)job;
    ngisSSHjobAttributes_t *attr = NULL;
    char *jobID = NULL;
    int result;
    pid_t pid = -1;
    ngisLog_t *log = NULL;
    static const char fName[] = "ngislSSHjobInitialize";
    
    NGIS_ASSERT(sshJob != NULL);
    NGIS_ASSERT(opts   != NULL);

    log = job->ngj_log;
    
    ngislSSHjobInitializeMember(sshJob);

    /* Function Queue */
    NGIS_LIST_INITIALIZE(ngisSSHjobFunc_t, &sshJob->ngsj_funcQueue);
    
    /* Create SSH Job Attribute from Invoke Server Options */
    attr = ngisSSHjobAttributesCreate(opts);
    if (attr == NULL) {
        ngisErrorPrint(log, fName, "Can't create SSH job attributes.\n");
        goto error;
    }
    sshJob->ngsj_attributes = attr;
    ngislSSHjobWarnIgnoredOptions(sshJob, opts);

    /* Set JobManager*/
    if ((attr->ngsja_jobManager == NULL) ||
        (strcmp(attr->ngsja_jobManager, "jobmanager-fork") == 0)) {
        sshJob->ngsj_jobManagerType = NGIS_SSH_JOB_MANAGER_NORMAL;
    } else if (strcmp(attr->ngsja_jobManager, "jobmanager-sge") == 0) {
        sshJob->ngsj_jobManagerType = NGIS_SSH_JOB_MANAGER_SGE;
    } else if (strcmp(attr->ngsja_jobManager, "jobmanager-pbs") == 0) {
        sshJob->ngsj_jobManagerType = NGIS_SSH_JOB_MANAGER_PBS;
    } else {
        ngisErrorPrint(log, fName, "Invalid job manager.\n");
        goto error;
    }
    
    /* Number of the job of queuing system */
    switch (attr->ngsja_jobBackend) {
    case NGIS_BACKEND_NORMAL:
        switch(sshJob->ngsj_jobManagerType) {
        case NGIS_SSH_JOB_MANAGER_PBS:
        case NGIS_SSH_JOB_MANAGER_SGE:
            sshJob->ngsj_nExecutables = 1;
            break;
        case NGIS_SSH_JOB_MANAGER_NORMAL:
            sshJob->ngsj_nExecutables = attr->ngsja_count;
            break;
        }
        break;
    case NGIS_BACKEND_MPI:
    case NGIS_BACKEND_BLACS:
        sshJob->ngsj_nExecutables = 1;
        break;
    default:
        NGIS_ASSERT_NOTREACHED();
    }

    /* Create Executable Handle */
    sshJob->ngsj_executables =
        ngislExecutableCreate(sshJob->ngsj_nExecutables, log);
    if (sshJob->ngsj_executables == NULL) {
        ngisErrorPrint(log, fName, "Can't create the executables.\n");
        goto error;
    }

    /* Execute SSH */
    pid = ngislSSHjobExecuteSSH(sshJob);
    if (pid < 0) {
        ngisErrorPrint(log, fName, "Can't execute SSH.\n");
        goto error;
    }

    /* Create Line Buffer */
    sshJob->ngsj_lBufStdout =
        ngisLineBufferCreate(sshJob->ngsj_stdio.ngsio_out, "\n");
    if (sshJob->ngsj_lBufStdout == NULL) {
        ngisErrorPrint(log, fName,
            "Can't create line buffer for the STDOUT.\n");
        goto error;
    }

    sshJob->ngsj_lBufStderr =
        ngisLineBufferCreate(sshJob->ngsj_stdio.ngsio_error, "\n");
    if (sshJob->ngsj_lBufStderr == NULL) {
        ngisErrorPrint(log, fName,
            "Can't create line buffer for the STDERR.\n");
        goto error;
    }

    /* Register function for reading STDERR */
    result = ngisLineBufferReadLine(
        sshJob->ngsj_lBufStderr, ngisSSHjobErrorCallback, sshJob);
    if (result == 0) {
        ngisErrorPrint(log, fName,
            "Can't register callback for reading STDERR.\n");
        goto error;
    }

    /* Prepare submitting the job */
    switch (sshJob->ngsj_jobManagerType) {
    case NGIS_SSH_JOB_MANAGER_NORMAL:
        result = ngisSSHjobPrepare(sshJob);
        break;
    case NGIS_SSH_JOB_MANAGER_SGE:
        result = ngisSSHjobSGEprepare(sshJob);
        break;
    case NGIS_SSH_JOB_MANAGER_PBS:
        result = ngisSSHjobPBSprepare(sshJob);
        break;
    default:
        NGIS_ASSERT_NOTREACHED();
    }
    if (result == 0) {
        ngisErrorPrint(log, fName, "Can't prepare.\n");
        goto error;
    }

    /* Job ID is process ID of SSH */
    jobID = ngisStrdupPrintf("%ld", (long)pid);
    if (jobID == NULL) {
        ngisErrorPrint(log, fName, "Can't create Job ID.\n");
        goto error;
    }

    result = ngisJobRegisterID(job, jobID);    
    if (result == 0) {
        ngisErrorPrint(log, fName,
            "Can't register Job ID to protocol.\n");
        goto error;
    }

    result = ngisSSHjobFunctionPop(sshJob);
    if (result == 0) {
        ngisErrorPrint(log, fName, "Can't execute the next process.\n");
        goto error;
    }

    NGIS_NULL_CHECK_AND_FREE(jobID);
 
    return 1;

    /* Error occurred */
error:
    NGIS_NULL_CHECK_AND_FREE(jobID);

    result = ngislSSHjobFinalize(job);
    if (result == 0) {
        ngisErrorPrint(log, fName, "Can't finalize the ssh job.\n");
    }
    return 0;
}
Beispiel #11
0
static int
ngislSSHjobTransferStdouterr(
    ngisSSHjob_t *job,
    ngisSSHjobTransferTarget_t targetType)
{
    ngisSSHjobFileTransfer_t *fileTransfer = NULL;
    int ret = 1;
    int result;
    char *remoteFileName = NULL;
    char *localFileName = NULL;
    char *remoteFileNameFormat = NULL;
    ngisLog_t *log;
    static const char fName[] = "ngislSSHjobTransferStdouterr";
    
    NGIS_ASSERT(job != NULL);

    log  = job->ngsj_log;

    switch (targetType) {
    case NGIS_SSH_JOB_TRANSFER_STDOUT:
        remoteFileNameFormat = "%s/stdout.*";
        localFileName        = job->ngsj_attributes->ngsja_stdoutFile;
        break;
    case NGIS_SSH_JOB_TRANSFER_STDERR:
        remoteFileNameFormat = "%s/stderr.*";
        localFileName        = job->ngsj_attributes->ngsja_stderrFile;
        break;
    default:
        NGIS_ASSERT_NOTREACHED();
    }

    remoteFileName = ngisStrdupPrintf(
        remoteFileNameFormat, job->ngsj_remoteTempdir);
    if (remoteFileName == NULL) {
        ngisErrorPrint(log, fName,
            "Can't copy string of temporary filename.\n");
        ret = 0;
        goto finalize;
    }

    fileTransfer = ngisSSHjobFileTransferCreate(
        job, localFileName, remoteFileName,
        NGIS_SSH_JOB_FILE_TRANSFER_REMOTE_TO_LOCAL);
    if (fileTransfer == NULL) {
        ngisErrorPrint(log, fName, "Can't create file transfer.\n");
        ret = 0;
        goto finalize;
    }
    result = ngisSSHjobFileTransferStart(fileTransfer);
    if (result == 0) {
        ngisErrorPrint(log, fName, "Can't start file transfer.\n");
        ret = 0;
        goto finalize;
    }
finalize:
    NGIS_NULL_CHECK_AND_FREE(remoteFileName);

    if ((ret == 0) && (fileTransfer != NULL)) {
        result = ngisSSHjobFileTransferDestroy(fileTransfer);
        if (result == 0) {
            ngisErrorPrint(log, fName, "Can't destroy file transfer.\n");
        }
    }
    return ret;
}