void
parseCOpt( char* opt, char* arg )
{
// first, try to understand what the option is they passed,
// given what kind of cod command we want to send. -cluster
// is only valid for activate, so if we're not doing that, we
// can assume they want -classad
char _cpath[] = "-classad";
char _clust[] = "-cluster";
char* parse_target = NULL;
// we already checked these, make sure we're not crazy
assert( opt[0] == '-' && opt[1] == 'c' );
if( cmd == CA_ACTIVATE_CLAIM ) {
if( ! (opt[2] && opt[3]) ) {
ambiguous( opt );
}
if( opt[2] != 'l' ) {
invalid( opt );
}
switch( opt[3] ) {
case 'a':
if( strncmp(_cpath, opt, strlen(opt)) ) {
invalid( opt );
}
parse_target = _cpath;
break;
case 'u':
if( strncmp(_clust, opt, strlen(opt)) ) {
invalid( opt );
}
parse_target = _clust;
break;
default:
invalid( opt );
break;
}
} else {
if( strncmp(_cpath, opt, strlen(opt)) ) {
invalid( opt );
}
parse_target = _cpath;
}
// now, make sure we got the arg
if( ! arg ) {
another( parse_target );
}
if( parse_target == _clust ) {
// we can check like that, since we're setting target to
// point to it, so we don't have to do a strcmp().
cluster_id = atoi( arg );
} else {
classad_path = strdup( arg );
}
}
void
parsePOpt( char* opt, char* arg )
{
// first, try to understand what the option is they passed,
// given what kind of cod command we want to send. -proc
// is only valid for activate, so if we're not doing that, we
// can assume they want -pool
char _pool[] = "-pool";
char _proc[] = "-proc";
char* parse_target = NULL;
// we already checked these, make sure we're not crazy
assert( opt[0] == '-' && opt[1] == 'p' );
if( cmd == CA_ACTIVATE_CLAIM ) {
if( ! opt[2] ) {
ambiguous( opt );
}
switch( opt[2] ) {
case 'o':
if( strncmp(_pool, opt, strlen(opt)) ) {
invalid( opt );
}
parse_target = _pool;
break;
case 'r':
if( strncmp(_proc, opt, strlen(opt)) ) {
invalid( opt );
}
parse_target = _proc;
break;
default:
invalid( opt );
break;
}
} else {
if( strncmp(_pool, opt, strlen(opt)) ) {
invalid( opt );
}
parse_target = _pool;
}
// now, make sure we got the arg
if( ! arg ) {
another( parse_target );
}
if( parse_target == _pool ) {
pool = new DCCollector( arg );
if( ! pool->addr() ) {
fprintf( stderr, "%s: %s\n", my_name, pool->error() );
exit( 1 );
}
} else {
proc_id = atoi( arg );
}
}
Node *
graph(char *target)
{
Node *node;
char *cnt;
cnt = rulecnt();
node = applyrules(target, cnt);
free(cnt);
cyclechk(node);
node->flags |= PROBABLE; /* make sure it doesn't get deleted */
vacuous(node);
ambiguous(node);
attribute(node);
return(node);
}
void overloaded_call() {
one overloaded(int);
two overloaded(double);
static_assert(sizeof(overloaded({0})) == sizeof(one), "bad overload"); // expected-warning {{braces around scalar init}}
static_assert(sizeof(overloaded({0.0})) == sizeof(two), "bad overload"); // expected-warning {{braces around scalar init}}
void ambiguous(int, double); // expected-note {{candidate}}
void ambiguous(double, int); // expected-note {{candidate}}
ambiguous({0}, {0}); // expected-error {{ambiguous}}
void emptylist(int);
void emptylist(int, int, int);
emptylist({});
emptylist({}, {}, {});
}
static void
ambiguous(Node *n)
{
Arc *a;
Rule *r = 0;
Arc *la;
int bad = 0;
la = 0;
for(a = n->prereqs; a; a = a->next){
if(a->n)
ambiguous(a->n);
if(*a->r->recipe == 0) continue;
if(r == 0)
r = a->r, la = a;
else{
if(r->recipe != a->r->recipe){
if((r->attr&META) && !(a->r->attr&META)){
la->flag |= TOGO;
r = a->r, la = a;
} else if(!(r->attr&META) && (a->r->attr&META)){
a->flag |= TOGO;
continue;
}
}
if(r->recipe != a->r->recipe){
if(bad == 0){
fprint(2, "mk: ambiguous recipes for %s:\n", n->name);
bad = 1;
trace(n->name, la);
}
trace(n->name, a);
}
}
}
if(bad)
Exit();
togo(n);
}
/*
Runs an interactive session of the program with this mode as basic mode
Gets commands from the user until it gets the "qq" command, at which time it
returns control.
It works as follows : get an input string from the user (leading whitespace
is chopped off by default in C++); look it up in the current CommandNode or
in its descendants (a prefix match is allowed if it is unique); execute it
if it is found, otherwise complain and get new input
*/
void CommandTree::run() const
{
try { activate(); }
catch(EntryError) { // we've got off to a very bad start
std::cout << "Internal error, failed to enter initial mode!" << std::endl;
}
runFlag = true;
const char* name; // needed in catch blocks
while (runFlag) // exit through |exitInteractive|, i.e., "qq"
try
{
const CommandTree* mode = modeStack.back(); // get current active mode
name = getCommand(mode->prompt()); // user input, edited by readline
CheckResult status = NotFound; // must initialise this before the call
CommandTree const* where;
CommandTree::const_iterator it = mode->look_up(name,status,where);
switch (status)
{
case NotFound:
// as a last resort try to locate |name| in descendant of an ancestor
for (int i=modeStack.size()-1; i-->0; )
{
it = modeStack[i]->look_up(name,status,where);
if (status==Found or status==PartialMatch)
{
mode=modeStack[i];
drop_to(*mode); // leave intermediate modes
goto found_case;
}
}
std::cout << name << ": not found" << std::endl;
break;
case Ambiguous: // then report all commands with this prefix
ambiguous(mode->extensions(name),name);
break;
case Found: case PartialMatch: // these behave identically now
found_case:
while (mode!=where)
for (unsigned int i=0; i<mode->n_desc(); ++i)
if (mode->nextMode(i).has_descendant(where))
{
mode->nextMode(i).activate(); // perform entry function
mode=&mode->nextMode(i); // change to this descendant mode
assert(modeStack.back()==mode); // it should have been pushed
break; // from |for| loop, see whether |mode==where| next
}
command_name = it->first; // set pointer to name of command
it->second(); // finally execute the command in its proper mode
}
} // try
catch (EntryError) {} // resume loop after user abort in |activate|
catch (error::InputError& e) // user abort in actual command execution
{ std::cerr << "input for command '" << name; e("' aborted"); }
catch (error::MemoryOverflow& e) { e("error: memory overflow"); }
catch (std::exception& e)
{
std::cerr << "error occurred in command '" << name << "': "
<< e.what() << std::endl;
}
catch (...)
{
std::cerr << std::endl << "unidentified error occurred" << std::endl;
}
// |for(runFlag)|
} // |run_from|
JobInfoCommunicator*
parseArgs( int argc, char* argv [] )
{
JobInfoCommunicator* jic = NULL;
char* job_input_ad = NULL;
char* job_output_ad = NULL;
char* job_keyword = NULL;
int job_cluster = -1;
int job_proc = -1;
int job_subproc = -1;
char* shadow_host = NULL;
char* job_stdin = NULL;
char* job_stdout = NULL;
char* job_stderr = NULL;
char* schedd_addr = NULL;
bool warn_multi_keyword = false;
bool warn_multi_input_ad = false;
bool warn_multi_output_ad = false;
bool warn_multi_cluster = false;
bool warn_multi_proc = false;
bool warn_multi_subproc = false;
bool warn_multi_stdin = false;
bool warn_multi_stdout = false;
bool warn_multi_stderr = false;
char *opt, *arg;
int opt_len;
char _jobinputad[] = "-job-input-ad";
char _joboutputad[] = "-job-output-ad";
char _jobkeyword[] = "-job-keyword";
char _jobcluster[] = "-job-cluster";
char _jobproc[] = "-job-proc";
char _jobsubproc[] = "-job-subproc";
char _jobstdin[] = "-job-stdin";
char _jobstdout[] = "-job-stdout";
char _jobstderr[] = "-job-stderr";
char _header[] = "-header";
char _gridshell[] = "-gridshell";
char _schedd_addr[] = "-schedd-addr";
char* target = NULL;
ASSERT( argc >= 2 );
char** tmp = argv;
for( tmp++; *tmp; tmp++ ) {
target = NULL;
opt = tmp[0];
arg = tmp[1];
opt_len = strlen( opt );
if( opt[0] != '-' ) {
// this must be a hostname...
free( shadow_host );
shadow_host = strdup( opt );
continue;
}
if( ! strncmp(opt, _header, opt_len) ) {
if( ! arg ) {
another( _header );
}
dprintf_header = strdup( arg );
DebugId = display_dprintf_header;
tmp++; // consume the arg so we don't get confused
continue;
}
if( ! strncmp(opt, _gridshell, opt_len) ) {
// just skip this one, we already processed this in
// main_pre_dc_init()
ASSERT( is_gridshell );
continue;
}
if( ! strncmp(opt, _schedd_addr, opt_len) ) {
if( ! arg ) {
another( _schedd_addr );
}
free( schedd_addr );
schedd_addr = strdup( arg );
tmp++; // consume the arg so we don't get confused
continue;
}
if( strncmp( "-job-", opt, MIN(opt_len,5)) ) {
invalid( opt );
}
if( opt_len < 6 ) {
ambiguous( opt );
}
switch( opt[5] ) {
case 'c':
if( strncmp(_jobcluster, opt, opt_len) ) {
invalid( opt );
}
target = _jobcluster;
break;
case 'k':
if( strncmp(_jobkeyword, opt, opt_len) ) {
invalid( opt );
}
target = _jobkeyword;
break;
case 'i':
if( strncmp(_jobinputad, opt, opt_len) ) {
invalid( opt );
}
target = _jobinputad;
break;
case 'o':
if( strncmp(_joboutputad, opt, opt_len) ) {
invalid( opt );
}
target = _joboutputad;
break;
case 'p':
if( strncmp(_jobproc, opt, opt_len) ) {
invalid( opt );
}
target = _jobproc;
break;
case 's':
if( !strncmp(_jobsubproc, opt, opt_len) ) {
target = _jobsubproc;
break;
} else if( !strncmp(_jobstdin, opt, opt_len) ) {
target = _jobstdin;
break;
} else if( !strncmp(_jobstdout, opt, opt_len) ) {
target = _jobstdout;
break;
} else if( !strncmp(_jobstderr, opt, opt_len) ) {
target = _jobstderr;
break;
}
invalid( opt );
break;
default:
invalid( opt );
break;
}
// now, make sure we got the arg
if( ! arg ) {
another( target );
} else {
// consume it for the purposes of the for() loop
tmp++;
}
if( target == _jobkeyword ) {
// we can check like that, since we're setting target to
// point to it, so we don't have to do a strcmp().
if( job_keyword ) {
warn_multi_keyword = true;
free( job_keyword );
}
job_keyword = strdup( arg );
} else if( target == _jobinputad ) {
if( job_input_ad ) {
warn_multi_input_ad = true;
free( job_input_ad );
}
job_input_ad = strdup( arg );
} else if( target == _joboutputad ) {
if( job_output_ad ) {
warn_multi_output_ad = true;
free( job_output_ad );
}
job_output_ad = strdup( arg );
} else if( target == _jobstdin ) {
if( job_stdin ) {
warn_multi_stdin = true;
free( job_stdin );
}
job_stdin = strdup( arg );
} else if( target == _jobstdout ) {
if( job_stdout ) {
warn_multi_stdout = true;
free( job_stdout );
}
job_stdout = strdup( arg );
} else if( target == _jobstderr ) {
if( job_stderr ) {
warn_multi_stderr = true;
free( job_stderr );
}
job_stderr = strdup( arg );
} else if( target == _jobcluster ) {
if( job_cluster >= 0 ) {
warn_multi_cluster = true;
}
job_cluster = atoi( arg );
if( job_cluster < 0 ) {
dprintf( D_ALWAYS,
"ERROR: Invalid value for '%s': \"%s\"\n",
_jobcluster, arg );
usage();
}
} else if( target == _jobproc ) {
if( job_proc >= 0 ) {
warn_multi_proc = true;
}
job_proc = atoi( arg );
if( job_proc < 0 ) {
dprintf( D_ALWAYS,
"ERROR: Invalid value for '%s': \"%s\"\n",
_jobproc, arg );
usage();
}
} else if( target == _jobsubproc ) {
if( job_subproc >= 0 ) {
warn_multi_subproc = true;
}
job_subproc = atoi( arg );
if( job_subproc < 0 ) {
dprintf( D_ALWAYS,
"ERROR: Invalid value for '%s': \"%s\"\n",
_jobsubproc, arg );
usage();
}
} else {
// Should never get here, since we'll hit usage above
// if we don't know what target option we're doing...
EXCEPT( "Programmer error in parsing arguments" );
}
}
if( job_stdin && job_stdin[0] == '-' && ! job_stdin[1] &&
job_input_ad && job_input_ad[0] == '-' && ! job_input_ad[1] ) {
dprintf( D_ALWAYS, "ERROR: Cannot use starter's stdin for both "
"the job stdin (%s) and to define the job ClassAd (%s). "
"Please do not use '-' for one of these two flags and "
"try again.\n", _jobstdin, _jobinputad );
usage();
}
if( job_output_ad && job_output_ad[0] == '-' && ! job_output_ad[1] &&
job_stdout && job_stdout[0] == '-' && ! job_stdout[1] ) {
dprintf( D_ALWAYS, "ERROR: Cannot use starter's stdout for both the "
"job stdout (%s) and to write the job's output ClassAd "
"(%s). Please do not use '-' for one of these two flags "
"and try again.\n", _jobstdout, _joboutputad );
usage();
}
if( warn_multi_keyword ) {
dprintf( D_ALWAYS, "WARNING: "
"multiple '%s' options given, using \"%s\"\n",
_jobkeyword, job_keyword );
}
if( warn_multi_input_ad ) {
dprintf( D_ALWAYS, "WARNING: "
"multiple '%s' options given, using \"%s\"\n",
_jobinputad, job_input_ad );
}
if( warn_multi_output_ad ) {
dprintf( D_ALWAYS, "WARNING: "
"multiple '%s' options given, using \"%s\"\n",
_joboutputad, job_output_ad );
}
if( warn_multi_stdin ) {
dprintf( D_ALWAYS, "WARNING: "
"multiple '%s' options given, using \"%s\"\n",
_jobstdin, job_stdin );
}
if( warn_multi_stdout ) {
dprintf( D_ALWAYS, "WARNING: "
"multiple '%s' options given, using \"%s\"\n",
_jobstdout, job_stdout );
}
if( warn_multi_stderr ) {
dprintf( D_ALWAYS, "WARNING: "
"multiple '%s' options given, using \"%s\"\n",
_jobstderr, job_stderr );
}
if( warn_multi_cluster ) {
dprintf( D_ALWAYS, "WARNING: "
"multiple '%s' options given, using \"%d\"\n",
_jobcluster, job_cluster );
}
if( warn_multi_proc ) {
dprintf( D_ALWAYS, "WARNING: "
"multiple '%s' options given, using \"%d\"\n",
_jobproc, job_proc );
}
if( warn_multi_subproc ) {
dprintf( D_ALWAYS, "WARNING: "
"multiple '%s' options given, using \"%d\"\n",
_jobsubproc, job_subproc );
}
if( shadow_host ) {
if( job_keyword ) {
dprintf( D_ALWAYS, "You cannot use '%s' and specify a "
"shadow host\n", _jobkeyword );
usage();
}
if( job_input_ad ) {
dprintf( D_ALWAYS, "You cannot use '%s' and specify a "
"shadow host\n", _jobinputad );
usage();
}
jic = new JICShadow( shadow_host );
free( shadow_host );
shadow_host = NULL;
free( schedd_addr );
free( job_output_ad );
free( job_stdin );
free( job_stdout );
free( job_stderr );
return jic;
}
if( ! (job_keyword || job_input_ad) ) {
dprintf( D_ALWAYS, "ERROR: You must specify either '%s' or '%s'\n",
_jobkeyword, _jobinputad );
usage();
}
// If the user didn't specify it, use -1 for cluster and/or
// proc, and the JIC subclasses will know they weren't on the
// command-line.
if( schedd_addr ) {
if( ! job_input_ad ) {
dprintf( D_ALWAYS, "ERROR: You must specify '%s' with '%s'\n",
_jobinputad, _schedd_addr );
usage();
}
jic = new JICLocalSchedd( job_input_ad, schedd_addr,
job_cluster, job_proc, job_subproc );
} else if( job_input_ad ) {
if( job_keyword ) {
jic = new JICLocalFile( job_input_ad, job_keyword,
job_cluster, job_proc, job_subproc );
} else {
jic = new JICLocalFile( job_input_ad, job_cluster, job_proc,
job_subproc );
}
} else {
ASSERT( job_keyword );
jic = new JICLocalConfig( job_keyword, job_cluster, job_proc,
job_subproc );
}
if( job_keyword ) {
free( job_keyword );
}
if( job_input_ad ) {
free( job_input_ad );
}
if( job_output_ad ) {
jic->setOutputAdFile( job_output_ad );
free( job_output_ad );
}
if( job_stdin ) {
jic->setStdin( job_stdin );
free( job_stdin );
}
if( job_stdout ) {
jic->setStdout( job_stdout );
free( job_stdout );
}
if( job_stderr ) {
jic->setStderr( job_stderr );
free( job_stderr );
}
if( schedd_addr ) {
free( schedd_addr );
}
return jic;
}
