getconfig.c

openPBS的开放源代码

	schd_PT_SMALL_WALLT_LIMIT = schd_val2sec(cfg_arg);
	return (0);
    }

    if (!strcmp(cfg_option, "PRIME_TIME_WALLT_LIMIT")) {
	schd_PT_WALLT_LIMIT = schd_val2sec(cfg_arg);
	return (0);
    }

    if (!strcmp(cfg_option, "NONPRIME_DRAIN_SYS")) {
	return schd_val2bool(cfg_arg, &schd_NONPRIME_DRAIN_SYS);
    }

    if (!strcmp(cfg_option, "NP_DRAIN_BACKTIME")) {
	schd_NP_DRAIN_BACKTIME = schd_val2sec(cfg_arg);
	return (0);
    }

    if (!strcmp(cfg_option, "NP_DRAIN_IDLETIME")) {
	schd_NP_DRAIN_IDLETIME = schd_val2sec(cfg_arg);
	return (0);
    }


    if (!strcmp(cfg_option, "SMALL_JOB_MAX")) {
	schd_SMALL_JOB_MAX = atoi(cfg_arg);
	return (0);
    }

    if (!strcmp(cfg_option, "WALLT_LIMIT_LARGE_JOB")) {
	schd_WALLT_LARGE_LIMIT = schd_val2sec(cfg_arg);
	return (0);
    }

    if (!strcmp(cfg_option, "WALLT_LIMIT_SMALL_JOB")) {
	schd_WALLT_SMALL_LIMIT = schd_val2sec(cfg_arg);
	return (0);
    }


    if (!strcmp(cfg_option, "MAX_QUEUED_TIME")) {
	schd_MAX_QUEUED_TIME = schd_val2sec(cfg_arg);
	return (0);
    }
    
    if (!strcmp(cfg_option, "SMALL_QUEUED_TIME")) {
	schd_SMALL_QUEUED_TIME = schd_val2sec(cfg_arg);
	return (0);
    }
    
    if (!strcmp(cfg_option, "INTERACTIVE_LONG_WAIT")) {
	schd_INTERACTIVE_LONG_WAIT = schd_val2sec(cfg_arg);
	return (0);
    }
    
    if (!strcmp(cfg_option, "SUBMIT_QUEUE")) {
	arg_to_qlist(cfg_arg, ",", &schd_SubmitQueue);
	return (0);
    }
    
    if (!strcmp(cfg_option, "BATCH_QUEUES")) {
	arg_to_qlist(cfg_arg, ",", &schd_BatchQueues);
	return (0);
    }
    
    if (!strcmp(cfg_option, "DEDICATED_QUEUES")) {
	arg_to_qlist(cfg_arg, ",", &schd_DedQueues);
	return (0);
    }

    if (!strcmp(cfg_option, "SPECIAL_QUEUE")) {
	if (schd_SpecialQueue)
	    free(schd_SpecialQueue);
	schd_SpecialQueue = schd_strdup(cfg_arg);
	if (schd_SpecialQueue == NULL) {
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id,
		"schd_strdup(schd_SpecialQueue)");
	    return (-1);
	}
	return (0);
    }

    if (!strcmp(cfg_option, "CHALLENGE_QUEUE_NAME")) {
	if (schd_ChallengeQueue)
	    free(schd_ChallengeQueue);
	schd_ChallengeQueue = schd_strdup(cfg_arg);
	if (schd_ChallengeQueue == NULL) {
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id,
		"schd_strdup(schd_ChallengeQueue)");
	    return (-1);
	}
	return (0);
    }
    if (!strcmp(cfg_option, "BACKGROUND_QUEUE_NAME")) {
	if (schd_BackgroundQueue)
	    free(schd_BackgroundQueue);
	schd_BackgroundQueue = schd_strdup(cfg_arg);
	if (schd_BackgroundQueue == NULL) {
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id,
		"schd_strdup(schd_BackgroundQueue)");
	    return (-1);
	}
	return (0);
    }

    if (!strcmp(cfg_option, "FAKE_MACHINE_MULT")) {
	schd_FAKE_MACH_MULT = atoi(cfg_arg);
	return (0);
    }
    
    if (!strcmp(cfg_option, "AVOID_FRAGMENTATION")) {
	return schd_val2bool(cfg_arg, &schd_AVOID_FRAGS);
    }

    if (!strcmp(cfg_option, "USAGE_WEIGHT")) {
	schd_USAGE_WEIGHT = atoi(cfg_arg);
	return (0);
    }
    
    if (!strcmp(cfg_option, "NODES_WEIGHT")) {
	schd_NODES_WEIGHT = atoi(cfg_arg);
	return (0);
    }
    
    if (!strcmp(cfg_option, "TIMEQ_WEIGHT")) {
	schd_TIMEQ_WEIGHT = atoi(cfg_arg);
	return (0);
    }
    
    
    /* Unknown option -- return an error. */
    return (-1);
}

static int
post_config(void)
{
    /* char   *id = "post_config"; */

    /* Set up per-queue primetime enforcement. */
    if (schd_BatchQueues)
        schd_reset_observed_pt(schd_BatchQueues);

    /* Post processing complete. */
    return (1);
}

static int 
validate_config(void)
{
    char   *id = "validate_config";
    char   *xit = "  Exiting.";
    /*
     * Some simple tests to make sure the configuration is
     * at least minimally rational.
     */

    if (schd_TEST_ONLY) {
	(void)sprintf(log_buffer, "NOTE: Scheduler is in testing-only mode.");
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s: %s\n", id, log_buffer));
    }

    DBPRT(("%s: validate submit queues\n", id));
    if (schd_SubmitQueue == NULL) {
	(void)sprintf(log_buffer, "No SUBMIT_QUEUE specified.%s", xit);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s\n", log_buffer));
	return (0);
    }
    if (schd_SubmitQueue->next != NULL) {
	(void)sprintf(log_buffer,
	    "Only one SUBMIT_QUEUE can be specified.%s", xit);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s\n", log_buffer));
	return (0);
    }

    DBPRT(("%s: validate batch queues\n", id));
    if (schd_BatchQueues == NULL) {
	(void)sprintf(log_buffer, "No BATCH_QUEUES specified.%s", xit);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s\n", log_buffer));
	return (0);
    }
    if (!qlist_unique(schd_BatchQueues)) {
	(void)sprintf(log_buffer, 
	    "Queues listed in BATCH_QUEUES cannot be repeated.%s", xit);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s\n", log_buffer));
	return (0);
    }

    if (schd_ENFORCE_PRIME_TIME) {
	DBPRT(("%s: validate primetime\n", id));
	if (schd_PRIME_TIME_START <= 0 || schd_PRIME_TIME_END <= 0) {
	    (void)sprintf(log_buffer, 
		"ENFORCE_PRIME_TIME set but PRIME_TIME_START/END is not "
		"specified.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}

        if (schd_PT_WALLT_LIMIT <= 0) {
            (void)sprintf(log_buffer, 
                "ENFORCE_PRIME_TIME set but no PRIME_TIME_WALLT_LIMIT given.");
            log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
            DBPRT(("%s\n", log_buffer));
            return (0);
        }

        if ((schd_PT_SMALL_NODE_LIMIT > 0) && 
            (schd_PT_SMALL_WALLT_LIMIT <= 0)) 
        {
            (void)sprintf(log_buffer, 
                "PRIMETIME_SMALL_NODE_LIMIT set but no "
		"PRIME_TIME_SMALL_WALLT_LIMIT given.");
            log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
            DBPRT(("%s\n", log_buffer));
            return (0);
        }

        if ((schd_PT_SMALL_NODE_LIMIT <= 0) && 
            (schd_PT_SMALL_WALLT_LIMIT > 0))
        {
            (void)sprintf(log_buffer, 
                "PRIME_TIME_SMALL_WALLT_LIMIT set but no "
		"PRIMETIME_SMALL_NODE_LIMIT given.");
            log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
            DBPRT(("%s\n", log_buffer));
            return (0);
        }
    }

    if (schd_SMALL_JOB_MAX) {
	if (schd_WALLT_LARGE_LIMIT <= 0) {
	    (void)sprintf(log_buffer, 
		"SMALL_JOB_MAX set but no WALLT_LIMIT_LARGE_JOB given.");
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}

	if (schd_WALLT_SMALL_LIMIT <= 0) {
	    (void)sprintf(log_buffer, 
		"SMALL_JOB_MAX set but no WALLT_LIMIT_SMALL_JOB given.");
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
    }

    if (schd_ENFORCE_DEDTIME) {
	DBPRT(("%s: validate dedicated queue\n", id));
	if (schd_DedQueues == NULL) {
	    (void)sprintf(log_buffer, 
		"ENFORCE_DEDICATED_TIME set but no dedicated queues "
		"specified.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	if (!qlist_one_per_host(schd_DedQueues)) {
	    (void)sprintf(log_buffer, 
	    "Only one DEDICATED_QUEUES entry per exechost allowed.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	if (!qlist_disjoint(schd_DedQueues, schd_BatchQueues)) {
	    (void)sprintf(log_buffer, 
	    "Queues in DEDICATED_QUEUES may not be listed in BATCH_QUEUES.%s",
		    xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	DBPRT(("%s: validate dedicated time command\n", id));
	if (schd_DEDTIME_COMMAND == NULL) {
	    (void)sprintf(log_buffer, 
		"ENFORCE_DEDICATED_TIME set but no DEDICATED_TIME_COMMAND "
		"specified.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
	}
	if (access(schd_DEDTIME_COMMAND, X_OK)) {
	    (void)sprintf(log_buffer, 
		"Execution denied for DEDICATED_TIME_COMMAND '%s'.%s", 
		schd_DEDTIME_COMMAND, xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);

	}
    }

    DBPRT(("%s: verify that queue sets are disjoint\n", id));
    if (!qlist_disjoint(schd_SubmitQueue, schd_BatchQueues)) {
	(void)sprintf(log_buffer, 
	    "SUBMIT_QUEUE %s cannot be listed in BATCH_QUEUES.%s",
		schd_SubmitQueue->queue->qname, xit);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	DBPRT(("%s\n", log_buffer));
	return (0);
    }

    if ((schd_FAKE_MACH_MULT < 1)) {
	    (void)sprintf(log_buffer, 
		"FAKE_MACHINE_MULT must be integer number > 0.%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
    }

    if ((schd_TIMEQ_WEIGHT < 0)||(schd_TIMEQ_WEIGHT > 10)) {
	    (void)sprintf(log_buffer, 
		"TIMEQ_WEIGHT must be integer number [0,1-10].%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
    }
    if ((schd_USAGE_WEIGHT < 0)||(schd_USAGE_WEIGHT > 10)) {
	    (void)sprintf(log_buffer, 
		"USAGE_WEIGHT must be integer number [0,1-10].%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
    }
    if ((schd_NODES_WEIGHT < 0)||(schd_NODES_WEIGHT > 10)) {
	    (void)sprintf(log_buffer, 
		"NODES_WEIGHT must be integer number [0,1-10].%s", xit);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	    DBPRT(("%s\n", log_buffer));
	    return (0);
    }

    DBPRT(("%s: Scheduler configuration appears valid.\n", id));
    return (1);
}

/* print_config(): Dump the current config to the log */
static void
print_config(void)
{
    char   *id = "print_config";
    QueueList *qptr;

    if (schd_TEST_ONLY) {
	(void)sprintf(log_buffer, "%-24s = %s", "TEST_ONLY", 
	    schd_bool2val(schd_TEST_ONLY));
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
    }

    if (schd_SubmitQueue) {
	(void)sprintf(log_buffer, "%-24s = %s@%s", "SUBMIT_QUEUE",
	    schd_SubmitQueue->queue->qname, schd_SubmitQueue->queue->exechost);
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
    }

    if (schd_BatchQueues) {
	for (qptr = schd_BatchQueues; qptr != NULL; qptr = qptr->next) {
	    (void)sprintf(log_buffer, "%-24s = %s@%s", 
		(qptr == schd_BatchQueues) ? "BATCH_QUEUES" : "",
		qptr->queue->qname, qptr->queue->exechost);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	}
    }

    if (schd_DedQueues) {
	for (qptr = schd_DedQueues; qptr != NULL; qptr = qptr->next) {
	    (void)sprintf(log_buffer, "%-24s = %s@%s", 
		(qptr == schd_DedQueues) ? "DEDICATED_QUEUES" : "",
		qptr->queue->qname, qptr->queue->exechost);
	    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
	}
    }

    (void)sprintf(log_buffer, "%-24s = %s", "ENFORCE_PRIME_TIME",
	schd_booltime2val(schd_ENFORCE_PRIME_TIME));
    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);

    (void)sprintf(log_buffer, "%-24s = %s", "PRIME_TIME_WALLT_LIMIT", 
        schd_sec2val(schd_PT_WALLT_LIMIT));
    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);

    if (schd_PT_SMALL_NODE_LIMIT) {
        (void)sprintf(log_buffer, "%-24s = %d", "PRIME_TIME_SMALL_NODE_LIMIT", 
            schd_PT_SMALL_NODE_LIMIT);
        log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);

        (void)sprintf(log_buffer, "%-24s = %s", "PRIME_TIME_SMALL_WALLT_LIMIT",
            schd_sec2val(schd_PT_SMALL_WALLT_LIMIT));
        log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
    }

    (void)sprintf(log_buffer, "%-24s = %s", "NONPRIME_DRAIN_SYS",
	schd_bool2val(schd_NONPRIME_DRAIN_SYS));
    log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);

    if (schd_NP_DRAIN_BACKTIME > 0) {
	(void)sprintf(log_buffer, "%-24s = %s", "NP_DRAIN_BACKTIME",
	    schd_sec2val(schd_NP_DRAIN_BACKTIME));
	log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_SERVER, id, log_buffer);
    }

    if (schd_NP_DRAIN_IDLETIME > 0) {