Example #1
0
/**
 * Request Process JOB_DESTROY
 */
static int
ngislRequestProcessJobDestroy(
    ngisiContext_t *context,
    char *requestName,
    char *id,
    int *error)
{
    static const char fName[] = "ngislRequestProcessJobDestroy";
    int result;

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Process %s.\n", requestName);

    result = ngisiJobProtocolDestroy(context, id, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Job Destroy process failed.\n");
        return 0;
    }

    result = ngislReply(context, NGISI_REPLY_SUCCESS, NULL, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Reply Job Destroy failed.\n");
        return 0;
    }

    /* Success */
    return 1;
}
Example #2
0
/**
 * Request Process EXIT
 */
static int
ngislRequestProcessExit(
    ngisiContext_t *context,
    char *requestName,
    int *error)
{
    static const char fName[] = "ngislRequestProcessExit";
    int result;

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Process %s.\n", requestName);

    result = ngislReply(context, NGISI_REPLY_SUCCESS, NULL, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Reply Exit failed.\n");
        /* Not return */
    }

    result = ngislRequestReaderStatusSet(
        context, NGISI_REQUEST_READER_STATUS_DONE, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Set the Request Reader status failed.\n");
    }

    /* Success */
    return 1;
}
Example #3
0
/**
 * Request Reader Initialize
 */
int
ngisiRequestReaderInitialize(
    ngisiContext_t *context,
    ngisiRequestReader_t *requestReader,
    int *error)
{
    static const char fName[] = "ngisiRequestReaderInitialize";
    int result;

    /* Check the arguments */
    assert(context != NULL);
    assert(requestReader != NULL);

    ngislRequestReaderInitializeMember(requestReader);

    result = ngisiMutexInitialize(
        context, &requestReader->ngisr_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Initialize the mutex failed.\n");
        return 0;
    }
    requestReader->ngisr_mutexInitialized = 1;

    result = ngisiCondInitialize(
        context, &requestReader->ngisr_cond, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Initialize the cond failed.\n");
        return 0;
    }
    requestReader->ngisr_condInitialized = 1;

    result = ngisiReadBufferInitialize(
        context, &requestReader->ngisr_readBuffer, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Initialize the Read Buffer failed.\n");
        return 0;
    }

    result = ngislRequestReaderStatusSet(
        context, NGISI_REQUEST_READER_STATUS_INITIALIZED, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Set the Request Reader Status failed.\n");
        return 0;
    }

    result = ngislRequestReaderStart(context, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Start the Request Reader failed.\n");
        return 0;
    }

    /* Success */
    return 1;
}
Example #4
0
/**
 * Reply Status
 */
static int
ngislReplyStatus(
    ngisiContext_t *context,
    ngisiReplyResult_t replyResult,
    ngisiJobStatus_t status,
    char *message,
    int *error)
{
    static const char fName[] = "ngislReplyStatus";
    char buf[NGISI_PROTOCOL_MAX];
    char *statusString;
    int result;

    /* Check the arguments */
    assert(context != NULL);

    statusString = NULL;
    buf[0] = '\0';

    if (replyResult == NGISI_REPLY_SUCCESS) {
        if (message != NULL) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_WARNING, fName,
                "Reply success requires no message : \"%s\".\n", message);
        }

        result = ngislReplyNotifyJobStatusGetString(
            context, status, &statusString, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Get string for status failed\n");
            return 0;
        }
        assert(statusString != NULL);

        snprintf(buf, sizeof(buf), "S %s", statusString);

    } else if (replyResult == NGISI_REPLY_FAIL) {
        snprintf(buf, sizeof(buf), "F%s%s",
            ((message != NULL) ? " " : ""),
            ((message != NULL) ? message : ""));

    } else {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Invalid Reply Result %d\n", replyResult);
        return 0;
    }

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Send Reply \"%s\".\n", buf);

    fprintf(NGISI_FP_REPLY, "%s%s", buf, NGISI_LINE_TERMINATOR_STR);

    /* Success */
    return 1;
}
Example #5
0
/**
 * Request Reader Finalize
 */
int
ngisiRequestReaderFinalize(
    ngisiContext_t *context,
    ngisiRequestReader_t *requestReader,
    int *error)
{
    static const char fName[] = "ngisiRequestReaderFinalize";
    int result;

    /* Check the arguments */
    assert(context != NULL);
    assert(requestReader != NULL);

    result = ngislRequestReaderStopCheck(context, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Stop check failed.\n");
        return 0;
    }

    result = ngisiReadBufferFinalize(
        context, &requestReader->ngisr_readBuffer, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Finalize the Read Buffer failed.\n");
        return 0;
    }

    if (requestReader->ngisr_condInitialized != 0) {
        requestReader->ngisr_condInitialized = 0;
        result = ngisiCondFinalize(
            context, &requestReader->ngisr_cond, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Finalize the cond failed.\n");
            return 0;
        }
    }

    if (requestReader->ngisr_mutexInitialized != 0) {
        requestReader->ngisr_mutexInitialized = 0;
        result = ngisiMutexFinalize(
            context, &requestReader->ngisr_mutex, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Finalize the mutex failed.\n");
            return 0;
        }
    }

    ngislRequestReaderInitializeMember(requestReader);

    /* Success */
    return 1;
}
Example #6
0
/**
 * RefreshCredential: Finalize.
 */
int
ngisiRefreshCredentialFinalize(
    ngisiContext_t *context,
    ngisiRefreshCredential_t *ref,
    int *error)
{
    static const char fName[] = "ngisiRefreshCredentialFinalize";
    int result;

    /* Check the arguments */
    assert(context != NULL);
    assert(ref != NULL);

    if ((ref->ngisrc_continue != 0) ||
        (ref->ngisrc_working != 0)) {
        result = ngislRefreshCredentialThreadStop(
            context, ref, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Can't stop the Refresh Credential thread.\n");
            return 0;
        }
    }

    if (ref->ngisrc_condInitialized != 0) {
        ref->ngisrc_condInitialized = 0;
        result = ngisiCondFinalize(
            context, &ref->ngisrc_cond, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Finalize the cond failed.\n");
            return 0;
        }
    }

    if (ref->ngisrc_mutexInitialized != 0) {
        ref->ngisrc_mutexInitialized = 0;
        result = ngisiMutexFinalize(
            context, &ref->ngisrc_mutex, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Finalize the mutex failed.\n");
            return 0;
        }
    }

    ngislRefreshCredentialInitializeMember(ref);

    /* Success */
    return 1;
}
Example #7
0
/**
 * Request Reader Start
 */
static int
ngislRequestReaderStart(
    ngisiContext_t *context,
    int *error)
{
    static const char fName[] = "ngislRequestReaderStart";
    ngisiRequestReader_t *requestReader;
    int result;

    /* Check the arguments */
    assert(context != NULL);

    requestReader = &context->ngisc_requestReader;

    requestReader->ngisr_continue = 1;
    requestReader->ngisr_working = 1;

    /* Create the Request Reader thread */
    result = globus_thread_create(
        &requestReader->ngisr_thread, NULL,
        ngislRequestReaderThread, context);
    if (result != 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Create the Request Reader thread failed.\n");
        return 0;
    }

    /* Success */
    return 1;
}
Example #8
0
/**
 * Notify Job Status
 */
int
ngisiNotifyJobStatus(
    ngisiContext_t *context,
    char *jobID,
    ngisiJobStatus_t status,
    char *message,
    int *error)
{
    static const char fName[] = "ngisiNotifyJobStatus";
    char buf[NGISI_PROTOCOL_MAX];
    char *statusString;
    int result;

    /* Check the arguments */
    assert(context != NULL);
    assert(jobID != NULL);

    statusString = NULL;

    result = ngislReplyNotifyJobStatusGetString(
        context, status, &statusString, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Get string for status failed\n");
        return 0;
    }

    assert(statusString != NULL);

    snprintf(buf, sizeof(buf), 
        "STATUS_NOTIFY %s %s%s%s",
        jobID, statusString,
        (message != NULL ? " " : ""),
        (message != NULL ? message : ""));

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Send Notify \"%s\".\n", buf);

    fprintf(NGISI_FP_NOTIFY,"%s%s", buf, NGISI_LINE_TERMINATOR_STR);

    /* Success */
    return 1;
}
Example #9
0
/**
 * Reply
 */
static int
ngislReply(
    ngisiContext_t *context,
    ngisiReplyResult_t replyResult,
    char *message,
    int *error)
{
    static const char fName[] = "ngislReply";
    char buf[NGISI_PROTOCOL_MAX];

    /* Check the arguments */
    assert(context != NULL);

    buf[0] = '\0';

    if (replyResult == NGISI_REPLY_SUCCESS) {
        if (message != NULL) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_WARNING, fName,
                "Reply success requires no message : \"%s\".\n", message);
        }

        snprintf(buf, sizeof(buf), "S");

    } else if (replyResult == NGISI_REPLY_FAIL) {
        snprintf(buf, sizeof(buf), "F%s%s",
            ((message != NULL) ? " " : ""),
            ((message != NULL) ? message : ""));

    } else {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Invalid Reply Result %d\n", replyResult);
        return 0;
    }

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Send Reply \"%s\".\n", buf);

    fprintf(NGISI_FP_REPLY, "%s%s", buf, NGISI_LINE_TERMINATOR_STR);

    /* Success */
    return 1;
}
Example #10
0
/**
 * RefreshCredential: Initialize.
 */
int
ngisiRefreshCredentialInitialize(
    ngisiContext_t *context,
    ngisiRefreshCredential_t *ref,
    int *error)
{
    static const char fName[] = "ngisiRefreshCredentialInitialize";
    int result;

    /* Check the arguments */
    assert(context != NULL);
    assert(ref != NULL);

    ngislRefreshCredentialInitializeMember(ref);

    result = ngisiMutexInitialize(
        context, &ref->ngisrc_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Initialize the mutex failed.\n");
        return 0;
    }
    ref->ngisrc_mutexInitialized = 1;

    result = ngisiCondInitialize(
        context, &ref->ngisrc_cond, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Initialize the cond failed.\n");
        return 0;
    }
    ref->ngisrc_condInitialized = 1;

    ref->ngisrc_updateInterval = 0; /* disable at first */

    ref->ngisrc_continue = 0; /* Thread is not invoked at first. */
    ref->ngisrc_working = 0;

    /* Success */
    return 1;
}
Example #11
0
/**
 * RefreshCredential: Start thread.
 */
static int
ngislRefreshCredentialThreadStart(
    ngisiContext_t *context,
    ngisiRefreshCredential_t *ref,
    int *error)
{
    static const char fName[] = "ngislRefreshCredentialThreadStart";
    int result;

    /* Check the arguments */
    assert(context != NULL);
    assert(ref != NULL);

    if (ref->ngisrc_working != 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Refresh Credential thread is already working.\n");
        return 0;
    }

    /* Check if the flag is valid */
    assert(ref->ngisrc_continue == 0);

    ref->ngisrc_continue = 1; /* TRUE */

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Create the Refresh Credential thread.\n");

    /* Create the Refresh Credential thread */
    result = globus_thread_create(
        &ref->ngisrc_thread, NULL,
        ngislRefreshCredentialThread, context);
    if (result != 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Can't create thread for Refresh Credential.\n");
        return 0;
    }

    /* Success */
    return 1;
}
Example #12
0
/**
 * Request Reader Stop Check
 */
static int
ngislRequestReaderStopCheck(
    ngisiContext_t *context,
    int *error)
{
    static const char fName[] = "ngislRequestReaderStopCheck";

    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Request Reader Stop check not implemented.\n");

    /* Success */
    return 1;
}
Example #13
0
static void
ngislCheckAttribute(
    ngisiContext_t *context,
    char *attr)
{
    int i;
    static const char fName[] = "ngislCheckAttribute";

    for (i = 0; ngislAttributeTable[i].attr != NULL; i++) {
        if (strcmp(attr, ngislAttributeTable[i].attr) == 0) {
            break;
        }
    }

    if (ngislAttributeTable[i].attr == NULL) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_WARNING, fName,
            "Unknown attribute \"%s\".\n", attr);
    } else if (ngislAttributeTable[i].supported == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_WARNING, fName,
            "Unsupported attribute \"%s\".\n", attr);
    }
}
Example #14
0
/**
 * Request Reader Thread
 */
static void *
ngislRequestReaderThread(
    void *threadArgument)
{
    static const char fName[] = "ngislRequestReaderThread";
    ngisiRequestReader_t *requestReader;
    ngisiContext_t *context;
    int *error, errorEntity;
    int result;

    assert(threadArgument != NULL);

    context = (ngisiContext_t *)threadArgument;
    requestReader = &context->ngisc_requestReader;
    error = &errorEntity;

    /* Check if the flag is valid */
    assert(requestReader->ngisr_continue != 0);

    requestReader->ngisr_working = 1;

    /* Process Request Reader */
    result = ngislRequestReaderProcess(context, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Process the Request Reader failed.\n");
    }

    result = ngisiRequestReaderSetDone(context, error);
    requestReader->ngisr_working = 0;
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Set done to the Request Reader failed.\n");
    }

    /* Success */
    return NULL;
}
Example #15
0
/**
 * Request Process Unknown2
 */
static int
ngislRequestProcessDefault(
    ngisiContext_t *context,
    int *error)
{
    static const char fName[] = "ngislRequestProcessDefault";

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Process Unknown.\n");

    /* Success */
    return 1;
}
Example #16
0
/**
 * Request Process Connection Closed
 */
static int
ngislRequestProcessClosed(
    ngisiContext_t *context,
    int *error)
{
    static const char fName[] = "ngislRequestProcessClosed";
    int result;

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Process Connection Closed.\n");

    result = ngislRequestReaderStatusSet(
        context, NGISI_REQUEST_READER_STATUS_DONE, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Set the Request Reader status failed.\n");
        return 0;
    }

    /* Success */
    return 1;
}
Example #17
0
static int
ngislReplyNotifyJobStatusGetString(
    ngisiContext_t *context,
    ngisiJobStatus_t status,
    char **statusString,
    int *error)
{
    static const char fName[] = "ngislReplyNotifyJobStatusGetString";

    /* Check the arguments */
    assert(context != NULL);
    assert(statusString != NULL);

    *statusString = "unknown";

    switch(status) {
    case NGISI_JOB_STATUS_INITIALIZED:
        *statusString = "PENDING"; /* Report as PENDING */
        break;

    case NGISI_JOB_STATUS_PENDING:
        *statusString = "PENDING";
        break;

    case NGISI_JOB_STATUS_ACTIVE:
        *statusString = "ACTIVE";
        break;

    case NGISI_JOB_STATUS_FAILED:
        *statusString = "FAILED";
        break;

    case NGISI_JOB_STATUS_DONE:
        *statusString = "DONE";
        break;

    default:
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Unknown Job Status %d.\n", status);
        return 0;
    }
   
    /* Success */
    return 1;
}
Example #18
0
/**
 * Request Reader Set Done
 */
int
ngisiRequestReaderSetDone(
    ngisiContext_t *context,
    int *error)
{
    static const char fName[] = "ngisiRequestReaderSetDone";
    ngisiRequestReader_t *requestReader;
    int result, locked;

    /* Check the arguments */
    assert(context != NULL);

    requestReader = &context->ngisc_requestReader;
    locked = 0;

    /* Lock the mutex */
    result = ngisiMutexLock(
        context, &requestReader->ngisr_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Lock the Request Reader mutex failed.\n");
        goto error;
    }
    locked = 1;

    /* Set done */
    requestReader->ngisr_working = 0;

    result = ngisiCondBroadcast(context,
        &requestReader->ngisr_cond, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Broadcast the cond failed.\n");
        goto error;
    }

    /* Unlock the mutex */
    locked = 0;
    result = ngisiMutexUnlock(
        context, &requestReader->ngisr_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Unlock the Request Reader mutex failed.\n");
        goto error;
    }

    /* Success */
    return 1;

    /* Error occurred */
error:

    if (locked != 0) {
        locked = 0;
        result = ngisiMutexUnlock(
            context, &requestReader->ngisr_mutex, NULL);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Unlock the Request Reader mutex failed.\n");
        }
    }

    /* Failed */
    return 0;
}
Example #19
0
/**
 * RefreshCredential: Set update interval.
 */
int
ngisiRefreshCredentialUpdateIntervalSet(
    ngisiContext_t *context,
    ngisiRefreshCredential_t *ref,
    int newInterval,
    int *error)
{
    static const char fName[] = "ngisiRefreshCredentialUpdateIntervalSet";
    time_t oldEventTime, nextEventTime;
    int mutexLocked, result, notify;
    int oldInterval;

    /* Check the arguments */
    assert(context != NULL);
    assert(ref != NULL);

    mutexLocked = 0;
    notify = 0;

    /* Lock */
    result = ngisiMutexLock(context, &ref->ngisrc_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Lock the mutex failed.\n");
        goto error;
    }
    mutexLocked = 1;

    oldInterval = ref->ngisrc_updateInterval;
    oldEventTime = ref->ngisrc_nextEventTime;

    if (newInterval != oldInterval) {
        notify = 1;

        if (newInterval > 0) {
            ref->ngisrc_updateInterval = newInterval;

            /* Select the early event time */
            nextEventTime = time(NULL) + newInterval;
            if ((oldEventTime > 0) && (nextEventTime > oldEventTime)) {
                nextEventTime = oldEventTime;
            }
            ref->ngisrc_nextEventTime = nextEventTime;
        } else {
            ref->ngisrc_updateInterval = 0;
            ref->ngisrc_nextEventTime = 0;
        }

        /* Notify signal */
        result = ngisiCondBroadcast(
            context, &ref->ngisrc_cond, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Cond signal failed.\n");
            goto error;
        }
    }

    /* Unlock */
    mutexLocked = 0;
    result = ngisiMutexUnlock(context, &ref->ngisrc_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Unlock the mutex failed.\n");
        goto error;
    }

    if ((notify != 0) && (newInterval > 0) &&
        (ref->ngisrc_continue == 0) && (ref->ngisrc_working == 0)) {
        /* Start the thread */
        result = ngislRefreshCredentialThreadStart(
            context, ref, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Can't start the Refresh Credential thread.\n");
            goto error;
        }
    }

    /* Success */
    return 1;

    /* Error occurred */
error:
    /* Unlock */
    if (mutexLocked != 0) {
        mutexLocked = 0;
        result = ngisiMutexUnlock(context, &ref->ngisrc_mutex, NULL);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Unlock the mutex failed.\n");
            return 0;
        }
    }

    /* Failed */
    return 0;
}
Example #20
0
/**
 * Request Process
 */
static int
ngislRequestProcess(
    ngisiContext_t *context,
    ngisiRequestType_t request,
    char *requestName,
    char *id,
    ngisiCreateAttr_t *attrs,
    int *finish,
    int *error)
{
    static const char fName[] = "ngislRequestProcess";
    int result;

    /* Check the arguments */
    assert(context != NULL);
    assert(finish != NULL);

    *finish = 0;

    switch(request) {
    case NGISI_REQUEST_JOB_CREATE:
        result = ngislRequestProcessJobCreate(
            context, requestName, id, attrs, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Process Job Create failed.\n");
            return 0;
        }
        break;

    case NGISI_REQUEST_JOB_STATUS:
        result = ngislRequestProcessJobStatus(
            context, requestName, id, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Process Job Status failed.\n");
            return 0;
        }
        break;

    case NGISI_REQUEST_JOB_DESTROY:
        result = ngislRequestProcessJobDestroy(
            context, requestName, id, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Process Job Destroy failed.\n");
            return 0;
        }
        break;

    case NGISI_REQUEST_QUERY_FEATURES:
        result = ngislRequestProcessQueryFeatures(
            context, requestName, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Process Query Features failed.\n");
            return 0;
        }
        break;

    case NGISI_REQUEST_EXIT:
        result = ngislRequestProcessExit(
            context, requestName, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Process Exit failed.\n");
            return 0;
        }
        *finish = 1;

        break;

    case NGISI_REQUEST_CLOSED:
        result = ngislRequestProcessClosed(context, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Process Connection closed failed.\n");
            return 0;
        }
        *finish = 1;

        break;

    case NGISI_REQUEST_UNKNOWN:
        result = ngislRequestProcessUnknown(context, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Process Unknown failed.\n");
            return 0;
        }

        break;

    default:
        result = ngislRequestProcessDefault(context, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Process Default failed.\n");
            return 0;
        }
        break;
    }

    /* Success */
    return 1;
}
Example #21
0
/**
 * Create Attr Add
 */
static int
ngislCreateAttrAdd(
    ngisiContext_t *context,
    ngisiCreateAttr_t *attr,
    char *name,
    char *value,
    int *error)
{
    static const char fName[] = "ngislCreateAttrAdd";
    ngisiCreateAttrElement_t *newArray, *oldArray;
    int i, newArraySize;
    char *newName, *newValue;

    /* Check the arguments */
    assert(context != NULL);
    assert(attr != NULL);
    assert(name != NULL);

    /* Check and renew size */
    if (attr->ngisca_nAttrs >= attr->ngisca_arraySize) {
        oldArray = attr->ngisca_attrs;

        if (attr->ngisca_arraySize <= 0) {
            newArraySize = NGISI_CREATE_ATTR_INITIAL_SIZE;
        } else {
            newArraySize = attr->ngisca_arraySize * 2;
        }

        newArray = (ngisiCreateAttrElement_t *)globus_libc_calloc(
            newArraySize, sizeof(ngisiCreateAttrElement_t));
        if (newArray == NULL) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Allocate the Create Attr failed.\n");
            return 0;
        }

        for (i = 0; i < newArraySize; i++) {
            newArray[i].ngisce_name    = NULL;
            newArray[i].ngisce_value   = NULL;
            newArray[i].ngisce_treated = 0;
        }

        for (i = 0; i < attr->ngisca_arraySize; i++) {
            newArray[i].ngisce_name    = oldArray[i].ngisce_name;
            newArray[i].ngisce_value   = oldArray[i].ngisce_value;
            newArray[i].ngisce_treated = oldArray[i].ngisce_treated;
        }

        attr->ngisca_arraySize = newArraySize;
        attr->ngisca_attrs = newArray;

        if (oldArray != NULL) {
            globus_libc_free(oldArray);
        }
    }
    assert(attr->ngisca_nAttrs < attr->ngisca_arraySize);

    /* Add to tail */
    i = attr->ngisca_nAttrs;

    newName = strdup(name);
    if (newName == NULL) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "strdup(new name) failed.\n");
        return 0;
    }

    if (value != NULL) {
        newValue = strdup(value);
        if (newValue == NULL) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "strdup(new value) failed.\n");
        return 0;
        }
    } else {
        newValue = NULL;
    }

    attr->ngisca_attrs[i].ngisce_name = newName;
    attr->ngisca_attrs[i].ngisce_value = newValue;

    attr->ngisca_nAttrs++;
    
    /* Success */
    return 1;
}
Example #22
0
/**
 * Request Attributes Read
 */
static int
ngislRequestAttributesRead(
    ngisiContext_t *context,
    FILE *readFp,
    ngisiReadBuffer_t *readBuffer,
    ngisiCreateAttr_t **attrs,
    int *error)
{
    static const char fName[] = "ngislRequestAttributesRead";
    char attrNameBuf[NGISI_CREATE_ATTR_STR_MAX];
    ngisiCreateAttr_t *newAttr;
    int result, finish, cur;
    char *p, *strStart;

    /* Check the arguments */
    assert(context != NULL);
    assert(readFp != NULL);
    assert(readBuffer != NULL);
    assert(attrs != NULL);

    *attrs = NULL;

    newAttr = (ngisiCreateAttr_t *)globus_libc_calloc(
        1, sizeof(ngisiCreateAttr_t));
    if (newAttr == NULL) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Allocate the Create Attr failed.\n");
        return 0;
    }

    result = ngislCreateAttrInitialize(context, newAttr, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Initialize the Create Attr failed.\n");
        return 0;
    }

    *attrs = newAttr;

    finish = 0;
    do {
        result = ngisiReadLine(
            context, NGISI_FP_REQUEST, readBuffer, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Read line failed.\n");
            return 0;
        }

        /* log */
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Read Attr \"%s\".\n", readBuffer->ngisrb_buf);


        strStart = readBuffer->ngisrb_buf;
        p = strStart;
        cur = 0;

        /* Get attribute name */
        while (isgraph((int)*p)) {
            attrNameBuf[cur] = *p;
            p++;
            cur++;
        }
        attrNameBuf[cur] = '\0';
        cur = 0;
     
        if (strlen(attrNameBuf) == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Attr name is 0.\n");
            return 0;
        }

        /* Find the value */
        while (isspace((int)*p)) {
            p++;
        }

        if (strcmp(attrNameBuf, NGISI_CREATE_ATTR_END) == 0) {
            finish = 1;
        } else {
            ngislCheckAttribute(context, attrNameBuf);
            result = ngislCreateAttrAdd(
                context, newAttr, attrNameBuf, p, error);
            if (result == 0) {
                ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                    "Add the Create Attr failed.\n");
                return 0;
            }
        }

    } while (finish == 0);

    /* Success */
    return 1;
}
Example #23
0
/**
 * Request Read
 */
static int
ngislRequestRead(
    ngisiContext_t *context,
    ngisiRequestType_t *request,
    char **requestName,
    char **id,
    ngisiCreateAttr_t **attrs,
    int *error)
{
    static const char fName[] = "ngislRequestRead";
    char idBuf[NGISI_ID_STR_MAX], *requestStr, *returnIdStr, *p;
    ngisiReadBuffer_t *readBuffer;
    int result, found, i, idCur;

    /* Check the arguments */
    assert(context != NULL);
    assert(request != NULL);
    assert(requestName != NULL);
    assert(id != NULL);
    assert(attrs != NULL);

    *request = NGISI_REQUEST_UNDEFINED;
    *requestName = NULL;
    *id = NULL;
    *attrs = NULL;

    p = NULL;
    requestStr = NULL;

    readBuffer = &context->ngisc_requestReader.ngisr_readBuffer;

    result = ngisiReadLine(
        context, NGISI_FP_REQUEST, readBuffer, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Read the Line failed.\n");
        return 0;
    }

    if (readBuffer->ngisrb_buf == NULL) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Read buffer is NULL.\n");
        return 0;
    }

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Read Request \"%s\".\n", readBuffer->ngisrb_buf);

    found = 0;
    for (i = 0; ngislRequestTypeTable[i].ngisrt_valid != 0; i++) {
        if (strncmp(readBuffer->ngisrb_buf,
            ngislRequestTypeTable[i].ngisrt_name,
            strlen(ngislRequestTypeTable[i].ngisrt_name)) == 0) {

            *request = ngislRequestTypeTable[i].ngisrt_type;
            requestStr = ngislRequestTypeTable[i].ngisrt_name;
            *requestName = requestStr;

            found = 1;
            break;
        }
    }

    if (found == 0) {
        if (readBuffer->ngisrb_reachEOF != 0) {
            *request = NGISI_REQUEST_CLOSED;
        } else {
            *request = NGISI_REQUEST_UNKNOWN;
        }

        return 1;
    }

    assert(found != 0);
    if ((*request == NGISI_REQUEST_EXIT) ||
        (*request == NGISI_REQUEST_QUERY_FEATURES)) {
        return 1;
    }

    p = readBuffer->ngisrb_buf;
    p += strlen(requestStr);

    /* Skip space */
    while (isspace((int)*p)) {
        p++;
    }

    /* Get the ID */
    idCur = 0;
    while (isgraph((int)*p)) {
        idBuf[idCur] = *p;
        idCur++;
        p++;
        if (idCur + 1 >= NGISI_ID_STR_MAX) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "id overflow (%d chars).\n", NGISI_ID_STR_MAX);
            return 0;
        }
    }
    idBuf[idCur] = '\0';

    if (idCur > 0) {
        returnIdStr = strdup(idBuf);
        if (returnIdStr == NULL) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "strdup(ID str) failed.\n");
            return 0;
        }
        *id = returnIdStr;
    } else {
        *id = NULL;
    }

    if (*request == NGISI_REQUEST_JOB_CREATE) {

        result = ngislRequestAttributesRead(
            context, NGISI_FP_REQUEST, readBuffer, attrs, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Read the Request Attributes failed.\n");
            return 0;
        }
        
    }

    /* Success */
    return 1;
}
Example #24
0
/**
 * Request Reader Process
 */
static int
ngislRequestReaderProcess(
    ngisiContext_t *context,
    int *error)
{
    static const char fName[] = "ngislRequestReaderProcess";
    ngisiRequestType_t request;
    ngisiCreateAttr_t *attrs;
    char *requestName, *id;
    int result, finish;

    /* Check the arguments */
    assert(context != NULL);

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Request Reader started working.\n");

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Request Reader pid=%ld.\n", (long)getpid());

    do {
        requestName = NULL;
        id = NULL;
        attrs = NULL;
        finish = 0;

        result = ngislRequestRead(
            context, &request, &requestName, &id, &attrs, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Read the Request failed.\n");
            goto error;
        }

        finish = 0;
        result = ngislRequestProcess(
            context, request, requestName, id, attrs, &finish, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Process the Request failed.\n");
            /* Return to loop */
        }

        requestName = NULL;

        if (id != NULL) {
            globus_libc_free(id);
            id = NULL;
        }

        if (attrs != NULL) {
            result = ngislCreateAttrFinalize(context, attrs, error);
            if (result == 0) {
                ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                    "Finalize the Create Attr failed.\n");
                goto error;
            }
            globus_libc_free(attrs);

            attrs = NULL;
        }

    } while (finish == 0);

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Request Reader thread exiting.\n");

    /* Success */
    return 1;

    /* Error occurred */
error:
    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
        "Request Reader thread exiting by error.\n");

    /* Failed */
    return 0;
}
Example #25
0
/**
 * Notify Job Create
 */
static int
ngislNotifyJobCreate(
    ngisiContext_t *context,
    char *requestID,
    ngisiReplyResult_t replyResult,
    char *jobID,
    char *message,
    int *error)
{
    static const char fName[] = "ngislNotifyJobCreate";
    char buf[NGISI_PROTOCOL_MAX];
    size_t length;

    /* Check the arguments */
    assert(context != NULL);
    assert(requestID != NULL);

    length = 0;

    length += snprintf(&buf[length], sizeof(buf) - length,
        "CREATE_NOTIFY %s ", requestID);
    
    if (replyResult == NGISI_REPLY_SUCCESS) {
        if (jobID == NULL) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "JobID is NULL.\n");
            return 0;
        }
        if (message != NULL) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_WARNING, fName,
                "Notify success requires no message : \"%s\".\n", message);
        }

        length += snprintf(&buf[length], sizeof(buf) - length,
            "S %s", jobID);

    } else if (replyResult == NGISI_REPLY_FAIL) {
        if (jobID != NULL) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_WARNING, fName,
                "Notify failure requires no jobID : \"%s\".\n", jobID);
        }

        length += snprintf(&buf[length], sizeof(buf) - length,
            "F%s%s",
            ((message != NULL) ? " " : ""),
            ((message != NULL) ? message : ""));

    } else {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Invalid Reply Result %d\n", replyResult);
        return 0;
    }

    /* log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Send Notify \"%s\".\n", buf);

    fprintf(NGISI_FP_NOTIFY,"%s%s", buf, NGISI_LINE_TERMINATOR_STR);

    /* Success */
    return 1;
}
Example #26
0
/**
 * RefreshCredential: Stop thread.
 */
static int
ngislRefreshCredentialThreadStop(
    ngisiContext_t *context,
    ngisiRefreshCredential_t *ref,
    int *error)
{
    static const char fName[] = "ngislRefreshCredentialThreadStop";
    int mutexLocked, result;

    /* Check the arguments */
    assert(context != NULL);
    assert(ref != NULL);

    mutexLocked = 0;

    if (ref->ngisrc_working == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
            "Refresh Credential thread is already stopped.\n");
        return 1;
    }


    /* Check if the flag is valid */
    assert(ref->ngisrc_continue != 0);

    /**
     * Tell the Refresh Credential thread to stop.
     */

    /* Lock */
    result = ngisiMutexLock(context, &ref->ngisrc_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Lock the mutex failed.\n");
        goto error;
    }
    mutexLocked = 1;

    /* Set the status */
    ref->ngisrc_continue = 0; /* to stop */

    /* Notify signal */
    result = ngisiCondBroadcast(
        context, &ref->ngisrc_cond, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Cond signal failed.\n");
        goto error;
    }

    /**
     * Suppress unlock and lock, to ignore CondBroadcast(!working) issue,
     * before the CondWait(!working) starts its proceedings.
     */

    /**
     * Wait the Refresh Credential thread to stop.
     */

    /* Suppress lock. already locked */

    /* Wait the status */
    while (ref->ngisrc_working != 0) {
        result = ngisiCondWait(context,
            &ref->ngisrc_cond, &ref->ngisrc_mutex,
            error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Can't wait the Condition Variable.\n");
            goto error;
        }
    }

    /* Unlock */
    mutexLocked = 0;
    result = ngisiMutexUnlock(context, &ref->ngisrc_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Unlock the mutex failed.\n");
        goto error;
    }

    /* Success */
    return 1;

    /* Error occurred */
error:
    /* Unlock */
    if (mutexLocked != 0) {
        mutexLocked = 0;
        result = ngisiMutexUnlock(context, &ref->ngisrc_mutex, NULL);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Unlock the mutex failed.\n");
            return 0;
        }
    }

    /* Failed */
    return 0;
}
Example #27
0
/**
 * RefreshCredential: thread.
 */
static void *
ngislRefreshCredentialThread(
    void *arg)
{
    static const char fName[] = "ngislRefreshCredentialThread";
    ngisiRefreshCredential_t *ref;
    int sleepSec, wasTimeout;
    ngisiContext_t *context;
    int mutexLocked, result;
    int *error, errorEntity;
    time_t now, timeoutTime;

    /* Check the arguments */
    assert(arg != NULL);

    context = (ngisiContext_t *)arg;
    ref = &context->ngisc_refreshCredential;
    error = &errorEntity;
    *error = 0;

    /* Check if the flag is valid */
    assert(ref->ngisrc_working == 0);

    mutexLocked = 0;
    ref->ngisrc_working = 1; /* TRUE */
    sleepSec = 0;

    /* Log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Refresh Credential thread invoked.\n");

    /* Lock */
    result = ngisiMutexLock(context, &ref->ngisrc_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Lock the mutex failed.\n");
        goto error;
    }
    mutexLocked = 1;

    sleepSec = 0; /* Do not wait at first. */

    /* Wait the status */
    while (ref->ngisrc_continue != 0) {
        wasTimeout = 0;

        /* Wait the event time. */
        if (sleepSec > 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
                "sleep %d sec for next update.\n", sleepSec);

            result = ngisiCondTimedWait(context,
                &ref->ngisrc_cond, &ref->ngisrc_mutex,
                sleepSec, &wasTimeout, error);
            if (result == 0) {
                ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                    "Can't wait the Condition Variable.\n");
                goto error;
            }
        }

        now = time(NULL);
        timeoutTime = ref->ngisrc_nextEventTime;

        /* Perform refresh credential. */
        if ((timeoutTime > 0) && (now >= timeoutTime)) {

            result = ngisiJobRefreshCredential(context, error);
            if (result == 0) {
                ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                    "Update the credential failed.\n");
                /* Not return */
            }

            if (ref->ngisrc_updateInterval > 0) {
                ref->ngisrc_nextEventTime = now + ref->ngisrc_updateInterval;
            } else {
                ref->ngisrc_nextEventTime = 0;
            }
        } 

        timeoutTime = ref->ngisrc_nextEventTime;
        sleepSec = NGISL_REFRESH_CREDENTIALS_SLEEP_WAIT_SEC;
        if (timeoutTime > 0) {
            sleepSec = timeoutTime - time(NULL);
        }
    }

    /* Unlock */
    mutexLocked = 0;
    result = ngisiMutexUnlock(context, &ref->ngisrc_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Unlock the mutex failed.\n");
        goto error;
    }

    /**
     * Tell the Main Thread that, Refresh Credential thread was stopped.
     */

    /* Log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Refresh Credential thread exiting.\n");

    /* Lock */
    result = ngisiMutexLock(context, &ref->ngisrc_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Lock the mutex failed.\n");
        goto error;
    }
    mutexLocked = 1;

    /* Set the status */
    ref->ngisrc_working = 0; /* FALSE */

    /* Notify signal */
    result = ngisiCondBroadcast(
        context, &ref->ngisrc_cond, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Cond signal failed.\n");
        goto error;
    }

    /* Unlock */
    mutexLocked = 0;
    result = ngisiMutexUnlock(context, &ref->ngisrc_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Unlock the mutex failed.\n");
        goto error;
    }

    /* Success */
    return NULL;

    /* Error occurred */
error:
    /* Set the status */
    ref->ngisrc_working = 0; /* FALSE */

    /* Log */
    ngisiLogPrintf(context, NGISI_LOG_LEVEL_DEBUG, fName,
        "Refresh Credential thread exiting by error.\n");

    /* Unlock */
    if (mutexLocked != 0) {
        /* Notify signal */
        result = ngisiCondBroadcast(
            context, &ref->ngisrc_cond, NULL);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Cond signal failed.\n");
        }

        mutexLocked = 0;
        result = ngisiMutexUnlock(context, &ref->ngisrc_mutex, NULL);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Unlock the mutex failed.\n");
        }
    }

    /* Failed */
    return NULL;
}
Example #28
0
/**
 * Request Reader Wait Done
 */
int
ngisiRequestReaderWaitDone(
    ngisiContext_t *context,
    int *error)
{
    static const char fName[] = "ngisiRequestReaderWaitDone";
    ngisiRequestReader_t *requestReader;
    int result, locked;

    /* Check the arguments */
    assert(context != NULL);

    requestReader = &context->ngisc_requestReader;
    locked = 0;

    /* Lock the mutex */
    result = ngisiMutexLock(
        context, &requestReader->ngisr_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Lock the Request Reader mutex failed.\n");
        goto error;
    }
    locked = 1;

    /* Wait done */
    while ((requestReader->ngisr_status < NGISI_REQUEST_READER_STATUS_DONE)
        && (requestReader->ngisr_working != 0)) {
        result = ngisiCondWait(context,
            &requestReader->ngisr_cond,
            &requestReader->ngisr_mutex, error);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Cond Wait the Request Reader failed.\n");
            goto error;
        }
    }

    /* Unlock the mutex */
    locked = 0;
    result = ngisiMutexUnlock(
        context, &requestReader->ngisr_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Unlock the Request Reader mutex failed.\n");
        goto error;
    }

    /* Success */
    return 1;

    /* Error occurred */
error:

    if (locked != 0) {
        locked = 0;
        result = ngisiMutexUnlock(
            context, &requestReader->ngisr_mutex, NULL);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Unlock the Request Reader mutex failed.\n");
        }
    }

    /* Failed */
    return 0;
}
Example #29
0
/**
 * Request Reader Status Set
 */
static int
ngislRequestReaderStatusSet(
    ngisiContext_t *context,
    ngisiRequestReaderStatus_t status,
    int *error)
{
    static const char fName[] = "ngislRequestReaderStatusSet";
    ngisiRequestReader_t *requestReader;
    int result, locked;

    /* Check the arguments */
    assert(context != NULL);

    requestReader = &context->ngisc_requestReader;
    locked = 0;

    /* Lock the mutex */
    result = ngisiMutexLock(
        context, &requestReader->ngisr_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Lock the Request Reader mutex failed.\n");
        goto error;
    }
    locked = 1;

    /* Update the status */
    requestReader->ngisr_status = status;

    /* Signal */
    result = ngisiCondBroadcast(
        context, &requestReader->ngisr_cond, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Cond Signal the Request Reader failed.\n");
        goto error;
    }

    /* Unlock the mutex */
    locked = 0;
    result = ngisiMutexUnlock(
        context, &requestReader->ngisr_mutex, error);
    if (result == 0) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Unlock the Request Reader mutex failed.\n");
        goto error;
    }

    /* Success */
    return 1;

    /* Error occurred */
error:

    if (locked != 0) {
        locked = 0;
        result = ngisiMutexUnlock(
            context, &requestReader->ngisr_mutex, NULL);
        if (result == 0) {
            ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                "Unlock the Request Reader mutex failed.\n");
        }
    }

    /* Failed */
    return 0;
}
Example #30
0
/**
 * Create Attr Get Remain
 * Returns attribute names which is not treated.
 */
int
ngisiCreateAttrGetRemain(
    ngisiContext_t *context,
    ngisiCreateAttr_t *attr,
    int *remainCount,
    char ***remainTable,
    int *error)
{
    static const char fName[] = "ngisiCreateAttrGetRemain";
    int size, i, cur;
    char **newTable, *name; 

    /* Check the arguments */
    assert(context != NULL);
    assert(attr != NULL);
    assert(remainCount != NULL);
    assert(remainTable != NULL);

    *remainCount = 0;
    *remainTable = NULL;

    /* Count the remain */
    size = 0;
    for (i = 0; i < attr->ngisca_nAttrs; i++) {
        assert(attr->ngisca_attrs[i].ngisce_name != NULL);
        if (attr->ngisca_attrs[i].ngisce_treated == 0) {
            size++;
        }
    }

    if (size == 0) {
        *remainCount = 0;
        *remainTable = NULL;

        /* Success */
        return 1;
    }

    newTable = (char **)globus_libc_calloc(size, sizeof(char *));
    if (newTable == NULL) {
        ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
            "Allocate the string table failed.\n");
        return 0;
    }

    cur = 0;
    for (i = 0; i < attr->ngisca_nAttrs; i++) {
        assert(attr->ngisca_attrs[i].ngisce_name != NULL);
        if (attr->ngisca_attrs[i].ngisce_treated == 0) {
            name = strdup(attr->ngisca_attrs[i].ngisce_name);
            if (name == NULL) {
                ngisiLogPrintf(context, NGISI_LOG_LEVEL_ERROR, fName,
                    "strdup() failed.\n");
                return 0;
            }
            newTable[cur] = name;
            cur++;
            assert(cur <= size);
        }
    }

    *remainCount = size;
    *remainTable = newTable;

    /* Success */
    return 1;
}