// Parse declaration of the form "type name" and construct
// matching HalideOpenGLArgument.
static HalideOpenGLArgument *parse_argument(void *user_context, const char *src,
const char *end) {
const char *name;
ArgumentType type = ARGTYPE_NONE;
if ((name = match_prefix(src, "float "))) {
type = ARGTYPE_FLOAT;
} else if ((name = match_prefix(src, "int "))) {
type = ARGTYPE_INT;
} else if ((name = match_prefix(src, "uint8 "))) {
type = ARGTYPE_UINT8;
} else if ((name = match_prefix(src, "uint16 "))) {
type = ARGTYPE_UINT16;
}
if (type == ARGTYPE_NONE) {
halide_error(user_context, "Internal error: argument type not supported");
return NULL;
}
HalideOpenGLArgument *arg =
(HalideOpenGLArgument *)malloc(sizeof(HalideOpenGLArgument));
arg->name = strndup(name, end - name);
arg->type = type;
arg->kind = ARGKIND_NONE;
arg->next = 0;
return arg;
}
void load_database_contexts(Context_Map* context_map)
{
int prefix_mask {};
std::ifstream buf;
buf.open(DBCONFIG_FILE);
assert(buf.is_open());
std::string line {};
while (!buf.eof())
{
getline(buf,line);
if (ignore_line(line)) continue;
else if (str_contains(line,'@'))
{
int port {};
std::string host {};
int db_num {};
// Complete at 00000111 (7)
// One bit is set each time one of the above is found.
// This allows for any number of newlines or comments.
uint8_t completion {};
Prefix p {match_prefix(prefix_mask, line)};
while ((completion != 7) && !buf.eof())
{
getline(buf,line);
if (ignore_line(line)) continue;
else if (str_contains(line,"port"))
{
port = extract_integer(line);
completion |= 1;
}
else if (str_contains(line, "number"))
{
db_num = extract_integer(line);
completion |= 2;
}
else if (str_contains(line, "host"))
{
host = extract_host(line);
completion |= 4;
}
}
assert(completion==7);
Redis::Context* c = new Redis::Context();
c->port = port;
c->host = host;
c->db_num = db_num;
context_map->set(p,c);
assert(context_map->get(p));
}
}
buf.close();
assert(prefix_mask >= max_prefix_mask);
assert(context_map);
}
static gboolean
g_resource_file_prefix_matches (GFile *parent,
GFile *descendant)
{
GResourceFile *parent_resource = G_RESOURCE_FILE (parent);
GResourceFile *descendant_resource = G_RESOURCE_FILE (descendant);
const char *remainder;
remainder = match_prefix (descendant_resource->path, parent_resource->path);
if (remainder != NULL && *remainder == '/')
return TRUE;
return FALSE;
}
// Perform case-insensitive match of string against pattern
static int match_prefix(const char *pattern, int pattern_len, const char *str) {
const char *or_str;
int i, j, len, res;
if ((or_str = (const char *) memchr(pattern, '|', pattern_len)) != NULL) {
res = match_prefix(pattern, or_str - pattern, str);
return res > 0 ? res :
match_prefix(or_str + 1, (pattern + pattern_len) - (or_str + 1), str);
}
i = j = 0;
res = -1;
for (; i < pattern_len; i++, j++) {
if (pattern[i] == '?' && str[j] != '\0') {
continue;
} else if (pattern[i] == '$') {
return str[j] == '\0' ? j : -1;
} else if (pattern[i] == '*') {
i++;
if (pattern[i] == '*') {
i++;
len = (int) strlen(str + j);
} else {
len = (int) strcspn(str + j, "/");
}
if (i == pattern_len) {
return j + len;
}
do {
res = match_prefix(pattern + i, pattern_len - i, str + j + len);
} while (res == -1 && len-- > 0);
return res == -1 ? -1 : j + res + len;
} else if (lowercase(&pattern[i]) != lowercase(&str[j])) {
return -1;
}
}
return j;
}
static char *
g_resource_file_get_relative_path (GFile *parent,
GFile *descendant)
{
GResourceFile *parent_resource = G_RESOURCE_FILE (parent);
GResourceFile *descendant_resource = G_RESOURCE_FILE (descendant);
const char *remainder;
remainder = match_prefix (descendant_resource->path, parent_resource->path);
if (remainder != NULL && *remainder == '/')
return g_strdup (remainder + 1);
return NULL;
}
void main_init(int argc , char * argv [])
{
char *testfile = NULL;
ClassAd *inputAd = NULL;
int i;
dprintf(D_ALWAYS, "main_init() called\n");
for (i=1; i<argc; i++ ) {
if (match_prefix(argv[i],"-withfile")) {
i++;
if (argc <= i) {
fprintf(stderr,
"ERROR: Argument -withfile requires a parameter\n ");
exit(1);
}
testfile = argv[i];
}
} // end of parsing command line options
if ( testfile ) {
FILE* fp = safe_fopen_wrapper(testfile,"r");
if (!fp) {
fprintf(stderr,"ERROR: Unable to open test file %s\n",
testfile);
DC_Exit(1);
}
int EndFlag=0, ErrorFlag=0, EmptyFlag=0;
if( !( inputAd=new ClassAd(fp,"***", EndFlag, ErrorFlag, EmptyFlag) ) ){
fprintf( stderr, "ERROR: Out of memory\n" );
DC_Exit( 1 );
}
fclose(fp);
if ( ErrorFlag || EmptyFlag ) {
fprintf( stderr, "ERROR - file %s does not contain a parseable ClassAd\n",
testfile);
DC_Exit(1);
}
// since this option is for testing, process then exit
ClassAd * resultAd = process_request(inputAd);
dPrintAd(D_ALWAYS, *resultAd);
DC_Exit( 0 );
}
}
int
main(int argc, char *argv[])
{
char *arg;
int nArgs = 0; // number of args
int i, result;
char* pool = NULL;
char* scheddName = NULL;
char* scheddAddr = NULL;
MyString method;
char *tmp;
myDistro->Init( argc, argv );
MyName = condor_basename(argv[0]);
config();
#if !defined(WIN32)
install_sig_handler(SIGPIPE, SIG_IGN );
#endif
// dig around in the config file looking for what the config file says
// about getting files from Condor. This defaults with the global variable
// initialization.
tmp = param( "SANDBOX_TRANSFER_METHOD" );
if ( tmp != NULL ) {
method = tmp;
free( tmp );
string_to_stm( method, st_method );
}
char **args = (char **)malloc(sizeof(char *) * argc); // args
if ( ! args) exit(2);
// parse the arguments.
for( argv++; (arg = *argv); argv++ ) {
if( arg[0] == '-' ) {
if( ! arg[1] ) {
usage();
}
switch( arg[1] ) {
case 'd':
// dprintf to console
dprintf_set_tool_debug("TOOL", 0);
break;
case 'c':
args[nArgs] = arg;
nArgs++;
argv++;
if( ! *argv ) {
fprintf( stderr,
"%s: -constraint requires another argument\n",
MyName);
exit(1);
}
args[nArgs] = *argv;
nArgs++;
break;
case 'a':
if( arg[2] && arg[2] == 'd' ) {
argv++;
if( ! *argv ) {
fprintf( stderr,
"%s: -addr requires another argument\n",
MyName);
exit(1);
}
if( is_valid_sinful(*argv) ) {
scheddAddr = strdup(*argv);
if( ! scheddAddr ) {
fprintf( stderr, "Out of Memory!\n" );
exit(1);
}
} else {
fprintf( stderr,
"%s: \"%s\" is not a valid address\n",
MyName, *argv );
fprintf( stderr, "Should be of the form "
"<ip.address.here:port>\n" );
fprintf( stderr,
"For example: <123.456.789.123:6789>\n" );
exit( 1 );
}
break;
}
All = true;
break;
case 'n':
// use the given name as the schedd name to connect to
argv++;
if( ! *argv ) {
fprintf( stderr, "%s: -name requires another argument\n",
MyName);
exit(1);
}
if ( scheddName ) free(scheddName);
scheddName = strdup(*argv);
break;
case 'p':
// use the given name as the central manager to query
argv++;
if( ! *argv ) {
fprintf( stderr, "%s: -pool requires another argument\n",
MyName);
exit(1);
}
if( pool ) {
free( pool );
}
pool = strdup( *argv );
break;
case 's':
argv++;
if( ! *argv ) {
fprintf( stderr, "%s: -stm requires another argument\n",
MyName);
exit(1);
}
method = *argv;
string_to_stm(method, st_method);
break;
case 'v':
version();
break;
case 'h':
usage(0);
break;
default:
fprintf( stderr, "Unrecognized option: %s\n", arg );
usage();
break;
}
} else {
if( All ) {
// If -all is set, there should be no other
// constraint arguments.
usage();
}
args[nArgs] = arg;
nArgs++;
}
}
// Check to make sure we have a valid sandbox transfer mechanism.
if (st_method == STM_UNKNOWN) {
fprintf( stderr,
"%s: Unknown sandbox transfer method: %s\n", MyName,
method.Value());
usage();
exit(1);
}
if( ! (All || nArgs) ) {
// We got no indication of what to act on
fprintf( stderr, "You did not specify any jobs\n" );
usage();
}
// We're done parsing args, now make sure we know how to
// contact the schedd.
if( ! scheddAddr ) {
// This will always do the right thing, even if either or
// both of scheddName or pool are NULL.
schedd = new DCSchedd( scheddName, pool );
} else {
schedd = new DCSchedd( scheddAddr );
}
if( ! schedd->locate() ) {
fprintf( stderr, "%s: %s\n", MyName, schedd->error() );
exit( 1 );
}
// Process the args.
if( All ) {
handleAll();
} else {
for(i = 0; i < nArgs; i++) {
if( match_prefix( args[i], "-constraint" ) ) {
i++;
addConstraint( args[i] );
} else {
procArg(args[i]);
}
}
}
// Sanity check: make certain we now have a constraint
if ( global_constraint.Length() <= 0 ) {
fprintf( stderr, "Unable to create a job constraint!\n");
exit(1);
}
fprintf(stdout,"Fetching data files...\n");
switch(st_method) {
case STM_USE_SCHEDD_ONLY:
{ // start block
// Get the sandbox directly from the schedd.
// And now, do the work.
CondorError errstack;
result = schedd->receiveJobSandbox(global_constraint.Value(),
&errstack);
if ( !result ) {
fprintf( stderr, "\n%s\n", errstack.getFullText(true).c_str() );
fprintf( stderr, "ERROR: Failed to spool job files.\n" );
exit(1);
}
// All done
return 0;
} //end block
break;
case STM_USE_TRANSFERD:
{ // start block
// NEW METHOD where we ask the schedd for a transferd, then get the
// files from the transferd
CondorError errstack;
ClassAd respad;
int invalid;
MyString reason;
MyString td_sinful;
MyString td_cap;
result = schedd->requestSandboxLocation(FTPD_DOWNLOAD,
global_constraint, FTP_CFTP, &respad, &errstack);
if ( !result ) {
fprintf( stderr, "\n%s\n", errstack.getFullText(true).c_str() );
fprintf( stderr, "ERROR: Failed to spool job files.\n" );
exit(1);
}
respad.LookupInteger(ATTR_TREQ_INVALID_REQUEST, invalid);
if (invalid == TRUE) {
fprintf( stderr, "ERROR: Failed to spool job files.\n" );
respad.LookupString(ATTR_TREQ_INVALID_REASON, reason);
fprintf( stderr, "%s\n", reason.Value());
exit(EXIT_FAILURE);
}
respad.LookupString(ATTR_TREQ_TD_SINFUL, td_sinful);
respad.LookupString(ATTR_TREQ_CAPABILITY, td_cap);
dprintf(D_ALWAYS,
"td: %s, cap: %s\n", td_sinful.Value(), td_cap.Value());
DCTransferD dctd(td_sinful.Value());
result = dctd.download_job_files(&respad, &errstack);
if ( !result ) {
fprintf( stderr, "\n%s\n", errstack.getFullText(true).c_str() );
fprintf( stderr, "ERROR: Failed to spool job files.\n" );
exit(1);
}
} // end block
break;
default:
EXCEPT("PROGRAMMER ERROR: st_method must be known.");
break;
}
// All done
return 0;
}
static void test_match_prefix(void) {
ASSERT(match_prefix("/api", 4, "/api") == 4);
ASSERT(match_prefix("/a/", 3, "/a/b/c") == 3);
ASSERT(match_prefix("/a/", 3, "/ab/c") == -1);
ASSERT(match_prefix("/*/", 3, "/ab/c") == 4);
ASSERT(match_prefix("**", 2, "/a/b/c") == 6);
ASSERT(match_prefix("/*", 2, "/a/b/c") == 2);
ASSERT(match_prefix("*/*", 3, "/a/b/c") == 2);
ASSERT(match_prefix("**/", 3, "/a/b/c") == 5);
ASSERT(match_prefix("**.foo|**.bar", 13, "a.bar") == 5);
ASSERT(match_prefix("a|b|cd", 6, "cdef") == 2);
ASSERT(match_prefix("a|b|c?", 6, "cdef") == 2);
ASSERT(match_prefix("a|?|cd", 6, "cdef") == 1);
ASSERT(match_prefix("/a/**.cgi", 9, "/foo/bar/x.cgi") == -1);
ASSERT(match_prefix("/a/**.cgi", 9, "/a/bar/x.cgi") == 12);
ASSERT(match_prefix("**/", 3, "/a/b/c") == 5);
ASSERT(match_prefix("**/$", 4, "/a/b/c") == -1);
ASSERT(match_prefix("**/$", 4, "/a/b/") == 5);
ASSERT(match_prefix("$", 1, "") == 0);
ASSERT(match_prefix("$", 1, "x") == -1);
ASSERT(match_prefix("*$", 2, "x") == 1);
ASSERT(match_prefix("/$", 2, "/") == 1);
ASSERT(match_prefix("**/$", 4, "/a/b/c") == -1);
ASSERT(match_prefix("**/$", 4, "/a/b/") == 5);
ASSERT(match_prefix("*", 1, "/hello/") == 0);
ASSERT(match_prefix("**.a$|**.b$", 11, "/a/b.b/") == -1);
ASSERT(match_prefix("**.a$|**.b$", 11, "/a/b.b") == 6);
ASSERT(match_prefix("**.a$|**.b$", 11, "/a/B.A") == 6);
ASSERT(match_prefix("**o$", 4, "HELLO") == 5);
}
END_TEST
START_TEST(test_match_prefix)
{
/* Adapted from unit_test.c */
/* Copyright (c) 2013-2015 the Civetweb developers */
/* Copyright (c) 2004-2013 Sergey Lyubka */
ck_assert_int_eq(4, match_prefix("/api", 4, "/api"));
ck_assert_int_eq(3, match_prefix("/a/", 3, "/a/b/c"));
ck_assert_int_eq(-1, match_prefix("/a/", 3, "/ab/c"));
ck_assert_int_eq(4, match_prefix("/*/", 3, "/ab/c"));
ck_assert_int_eq(6, match_prefix("**", 2, "/a/b/c"));
ck_assert_int_eq(2, match_prefix("/*", 2, "/a/b/c"));
ck_assert_int_eq(2, match_prefix("*/*", 3, "/a/b/c"));
ck_assert_int_eq(5, match_prefix("**/", 3, "/a/b/c"));
ck_assert_int_eq(5, match_prefix("**.foo|**.bar", 13, "a.bar"));
ck_assert_int_eq(2, match_prefix("a|b|cd", 6, "cdef"));
ck_assert_int_eq(2, match_prefix("a|b|c?", 6, "cdef"));
ck_assert_int_eq(1, match_prefix("a|?|cd", 6, "cdef"));
ck_assert_int_eq(-1, match_prefix("/a/**.cgi", 9, "/foo/bar/x.cgi"));
ck_assert_int_eq(12, match_prefix("/a/**.cgi", 9, "/a/bar/x.cgi"));
ck_assert_int_eq(5, match_prefix("**/", 3, "/a/b/c"));
ck_assert_int_eq(-1, match_prefix("**/$", 4, "/a/b/c"));
ck_assert_int_eq(5, match_prefix("**/$", 4, "/a/b/"));
ck_assert_int_eq(0, match_prefix("$", 1, ""));
ck_assert_int_eq(-1, match_prefix("$", 1, "x"));
ck_assert_int_eq(1, match_prefix("*$", 2, "x"));
ck_assert_int_eq(1, match_prefix("/$", 2, "/"));
ck_assert_int_eq(-1, match_prefix("**/$", 4, "/a/b/c"));
ck_assert_int_eq(5, match_prefix("**/$", 4, "/a/b/"));
ck_assert_int_eq(0, match_prefix("*", 1, "/hello/"));
ck_assert_int_eq(-1, match_prefix("**.a$|**.b$", 11, "/a/b.b/"));
ck_assert_int_eq(6, match_prefix("**.a$|**.b$", 11, "/a/b.b"));
ck_assert_int_eq(6, match_prefix("**.a$|**.b$", 11, "/a/B.A"));
ck_assert_int_eq(5, match_prefix("**o$", 4, "HELLO"));
}
int
main(int argc, char *argv[])
{
has_proc = false;
MyString constraint;
Qmgr_connection *q;
int nextarg = 1, cluster=0, proc=0;
bool UseConstraint = false;
MyString schedd_name;
MyString pool_name;
ExprTree* value_expr;
myDistro->Init( argc, argv );
config();
#if !defined(WIN32)
install_sig_handler(SIGPIPE, SIG_IGN );
#endif
if (argc < 2) {
usage(argv[0]);
}
// if -debug is present, it must be first. sigh.
if (argv[nextarg][0] == '-' && argv[nextarg][1] == 'd') {
// output dprintf messages to stderror at TOOL_DEBUG level
dprintf_set_tool_debug("TOOL", 0);
nextarg++;
}
// if it is present, it must be first after debug.
if (argv[nextarg][0] == '-' && argv[nextarg][1] == 'n') {
nextarg++;
// use the given name as the schedd name to connect to
if (argc <= nextarg) {
fprintf(stderr, "%s: -n requires another argument\n",
argv[0]);
exit(1);
}
schedd_name = argv[nextarg];
nextarg++;
}
if (argc <= nextarg) {
usage(argv[0]);
}
// if it is present, it must be just after -n flag
if (argv[nextarg][0] == '-' && argv[nextarg][1] == 'p') {
nextarg++;
if (argc <= nextarg) {
fprintf(stderr, "%s: -pool requires another argument\n",
argv[0]);
exit(1);
}
pool_name = argv[nextarg];
nextarg++;
}
DCSchedd schedd((schedd_name.Length() == 0) ? NULL : schedd_name.Value(),
(pool_name.Length() == 0) ? NULL : pool_name.Value());
if ( schedd.locate() == false ) {
if (schedd_name == "") {
fprintf( stderr, "%s: ERROR: Can't find address of local schedd\n",
argv[0] );
exit(1);
}
if (pool_name == "") {
fprintf( stderr, "%s: No such schedd named %s in local pool\n",
argv[0], schedd_name.Value() );
} else {
fprintf( stderr, "%s: No such schedd named %s in "
"pool %s\n",
argv[0], schedd_name.Value(), pool_name.Value() );
}
exit(1);
}
// Open job queue
q = ConnectQ( schedd.addr(), 0, false, NULL, NULL, schedd.version() );
if( !q ) {
fprintf( stderr, "Failed to connect to queue manager %s\n",
schedd.addr() );
exit(1);
}
if (argc <= nextarg) {
usage(argv[0]);
}
if (isdigit(argv[nextarg][0])) {
char *tmp;
cluster = strtol(argv[nextarg], &tmp, 10);
if (cluster <= 0) {
fprintf( stderr, "Invalid cluster # from %s.\n", argv[nextarg]);
exit(1);
}
if (*tmp == '.') {
proc = strtol(tmp + 1, &tmp, 10);
if (cluster <= 0) {
fprintf( stderr, "Invalid proc # from %s.\n", argv[nextarg]);
exit(1);
}
UseConstraint = false;
has_proc = true;
} else {
constraint.formatstr("(%s == %d)", ATTR_CLUSTER_ID, cluster);
UseConstraint = true;
}
nextarg++;
} else if (!match_prefix(argv[nextarg], "-constraint")) {
constraint.formatstr("(%s == \"%s\")", ATTR_OWNER, argv[nextarg]);
nextarg++;
UseConstraint = true;
}
if (argc <= nextarg) {
usage(argv[0]);
}
while (match_prefix(argv[nextarg], "-constraint")) {
if ( has_proc ){
fprintf(stderr, "condor_qedit: proc_id specified. Ignoring constraint option\n");
nextarg+=2;
continue;
}
nextarg++;
if (argc <= nextarg) {
usage(argv[0]);
}
if ( !UseConstraint ){
constraint = argv[nextarg];
}
else{
constraint = "( " + constraint + " ) && " + argv[nextarg];
}
nextarg++;
UseConstraint = true;
}
if (argc <= nextarg) {
usage(argv[0]);
}
for (; nextarg < argc; nextarg += 2) {
if (argc <= nextarg+1) {
usage(argv[0]);
}
if (ProtectedAttribute(argv[nextarg])) {
fprintf(stderr, "Update of attribute \"%s\" is not allowed.\n",
argv[nextarg]);
fprintf(stderr,
"Transaction failed. No attributes were set.\n");
exit(1);
}
// Check validity of attribute-name
if ( blankline(argv[nextarg]) ||
!IsValidAttrName(argv[nextarg]) )
{
fprintf(stderr,
"Update aborted, illegal attribute-name specified for attribute \"%s\".\n",
argv[nextarg]);
fprintf(stderr,
"Transaction failed. No attributes were set.\n");
exit(1);
}
// Check validity of attribute-value
value_expr = NULL;
if ( blankline(argv[nextarg+1]) ||
!IsValidAttrValue(argv[nextarg+1]) ||
ParseClassAdRvalExpr(argv[nextarg+1], value_expr) )
{
fprintf(stderr,
"Update aborted, illegal attribute-value specified for attribute \"%s\".\n",
argv[nextarg]);
fprintf(stderr,
"Transaction failed. No attributes were set.\n");
exit(1);
}
if (value_expr) delete value_expr;
if (UseConstraint) {
// Try to communicate with the newer protocol first
if (SetAttributeByConstraint(constraint.Value(),
argv[nextarg],
argv[nextarg+1],
SETDIRTY) < 0) {
if (SetAttributeByConstraint(constraint.Value(),
argv[nextarg],
argv[nextarg+1]) < 0) {
fprintf(stderr,
"Failed to set attribute \"%s\" by constraint: %s\n",
argv[nextarg], constraint.Value());
fprintf(stderr,
"Transaction failed. No attributes were set.\n");
exit(1);
}
}
} else {
if (SetAttribute(cluster, proc, argv[nextarg],
argv[nextarg+1], SETDIRTY) < 0) {
fprintf(stderr,
"Failed to set attribute \"%s\" for job %d.%d.\n",
argv[nextarg], cluster, proc);
fprintf(stderr,
"Transaction failed. No attributes were set.\n");
exit(1);
}
}
printf("Set attribute \"%s\".\n", argv[nextarg]);
}
if (!DisconnectQ(q)) {
fprintf(stderr,
"Queue transaction failed. No attributes were set.\n");
exit(1);
}
return 0;
}
int
main( int argc, char *argv[] )
{
char *arg;
char **args = (char **)malloc(sizeof(char *)*(argc - 1)); // args
int nArgs = 0; // number of args
int i;
char* cmd_str;
DCCollector* pool = NULL;
char* scheddName = NULL;
char* scheddAddr = NULL;
// Initialize our global variables
has_constraint = false;
myDistro->Init( argc, argv );
MyName = strrchr( argv[0], DIR_DELIM_CHAR );
if( !MyName ) {
MyName = argv[0];
} else {
MyName++;
}
cmd_str = strchr( MyName, '_');
// we match modes based on characters after the '_'. This means
// 'condor_hold.exe' or 'condor_hold_wrapped' are all legal argv[0]'s
// for condor_hold.
if (cmd_str && strncasecmp( cmd_str, "_hold", strlen("_hold") ) == MATCH) {
mode = JA_HOLD_JOBS;
} else if ( cmd_str &&
strncasecmp( cmd_str, "_release", strlen("_release") ) == MATCH ) {
mode = JA_RELEASE_JOBS;
} else if ( cmd_str &&
strncasecmp( cmd_str, "_suspend", strlen("_suspend") ) == MATCH ) {
mode = JA_SUSPEND_JOBS;
} else if ( cmd_str &&
strncasecmp( cmd_str, "_continue", strlen("_continue") ) == MATCH ) {
mode = JA_CONTINUE_JOBS;
}else if ( cmd_str &&
strncasecmp( cmd_str, "_rm", strlen("_rm") ) == MATCH ) {
mode = JA_REMOVE_JOBS;
} else if( cmd_str && ! strncasecmp(cmd_str, "_vacate_job",
strlen("_vacate_job")) ) {
mode = JA_VACATE_JOBS;
} else {
// don't know what mode we're using, so bail.
fprintf( stderr, "Unrecognized command name, \"%s\"\n", MyName );
usage();
}
config();
if( argc < 2 ) {
// We got no indication of what to act on
fprintf( stderr, "You did not specify any jobs\n" );
usage();
}
#if !defined(WIN32)
install_sig_handler(SIGPIPE, SIG_IGN );
#endif
for( argv++; (arg = *argv); argv++ ) {
if( arg[0] == '-' ) {
if (match_prefix(arg, "-debug")) {
// dprintf to console
dprintf_set_tool_debug("TOOL", 0);
} else if (match_prefix(arg, "-constraint")) {
args[nArgs] = arg;
nArgs++;
argv++;
if( ! *argv ) {
fprintf( stderr,
"%s: -constraint requires another argument\n",
MyName);
exit(1);
}
args[nArgs] = *argv;
nArgs++;
ConstraintArg = true;
} else if (match_prefix(arg, "-all")) {
All = true;
} else if (match_prefix(arg, "-addr")) {
argv++;
if( ! *argv ) {
fprintf( stderr,
"%s: -addr requires another argument\n",
MyName);
exit(1);
}
if( is_valid_sinful(*argv) ) {
scheddAddr = strdup(*argv);
if( ! scheddAddr ) {
fprintf( stderr, "Out of memory!\n" );
exit(1);
}
} else {
fprintf( stderr,
"%s: \"%s\" is not a valid address\n",
MyName, *argv );
fprintf( stderr, "Should be of the form "
"<ip.address.here:port>\n" );
fprintf( stderr,
"For example: <123.456.789.123:6789>\n" );
exit( 1 );
}
} else if (match_prefix(arg, "-reason")) {
argv++;
if( ! *argv ) {
fprintf( stderr,
"%s: -reason requires another argument\n",
MyName);
exit(1);
}
actionReason = strdup(*argv);
if( ! actionReason ) {
fprintf( stderr, "Out of memory!\n" );
exit(1);
}
} else if (match_prefix(arg, "-subcode")) {
argv++;
if( ! *argv ) {
fprintf( stderr,
"%s: -subcode requires another argument\n",
MyName);
exit(1);
}
char *end = NULL;
long code = strtol(*argv,&end,10);
if( code == LONG_MIN || !end || *end || end==*argv ) {
fprintf( stderr, "Invalid -subcode %s!\n", *argv );
exit(1);
}
holdReasonSubCode = strdup(*argv);
ASSERT( holdReasonSubCode );
} else if (match_prefix(arg, "-forcex")) {
if( mode == JA_REMOVE_JOBS ) {
mode = JA_REMOVE_X_JOBS;
} else {
fprintf( stderr,
"-forcex is only valid with condor_rm\n" );
usage();
}
} else if (match_prefix(arg, "-fast")) {
if( mode == JA_VACATE_JOBS ) {
mode = JA_VACATE_FAST_JOBS;
} else {
fprintf( stderr,
"-fast is only valid with condor_vacate_job\n" );
usage();
}
} else if (match_prefix(arg, "-name")) {
// use the given name as the schedd name to connect to
argv++;
if( ! *argv ) {
fprintf( stderr, "%s: -name requires another argument\n",
MyName);
exit(1);
}
if( !(scheddName = get_daemon_name(*argv)) ) {
fprintf( stderr, "%s: unknown host %s\n",
MyName, get_host_part(*argv) );
exit(1);
}
} else if (match_prefix(arg, "-pool")) {
// use the given name as the central manager to query
argv++;
if( ! *argv ) {
fprintf( stderr, "%s: -pool requires another argument\n",
MyName);
exit(1);
}
if( pool ) {
delete pool;
}
pool = new DCCollector( *argv );
if( ! pool->addr() ) {
fprintf( stderr, "%s: %s\n", MyName, pool->error() );
exit(1);
}
} else if (match_prefix(arg, "-version")) {
version();
} else if (match_prefix(arg, "-help")) {
usage(0);
} else {
fprintf( stderr, "Unrecognized option: %s\n", arg );
usage();
}
} else {
if( All ) {
// If -all is set, there should be no other
// constraint arguments.
usage();
}
args[nArgs] = arg;
nArgs++;
UserJobIdArg = true;
}
}
if( ! (All || nArgs) ) {
// We got no indication of what to act on
fprintf( stderr, "You did not specify any jobs\n" );
usage();
}
if ( ConstraintArg && UserJobIdArg ) {
fprintf( stderr, "You can't use both -constraint and usernames or job ids\n" );
usage();
}
// Pick the default reason if the user didn't specify one
if( actionReason == NULL ) {
switch( mode ) {
case JA_RELEASE_JOBS:
actionReason = strdup("via condor_release");
break;
case JA_REMOVE_X_JOBS:
actionReason = strdup("via condor_rm -forcex");
break;
case JA_REMOVE_JOBS:
actionReason = strdup("via condor_rm");
break;
case JA_HOLD_JOBS:
actionReason = strdup("via condor_hold");
break;
case JA_SUSPEND_JOBS:
actionReason = strdup("via condor_suspend");
break;
case JA_CONTINUE_JOBS:
actionReason = strdup("via condor_continue");
break;
default:
actionReason = NULL;
}
}
// We're done parsing args, now make sure we know how to
// contact the schedd.
if( ! scheddAddr ) {
// This will always do the right thing, even if either or
// both of scheddName or pool are NULL.
schedd = new DCSchedd( scheddName, pool ? pool->addr() : NULL );
} else {
schedd = new DCSchedd( scheddAddr );
}
if( ! schedd->locate() ) {
fprintf( stderr, "%s: %s\n", MyName, schedd->error() );
exit( 1 );
}
// Special case for condor_rm -forcex: a configuration
// setting can disable this functionality. The real
// validation is done in the schedd, but we can catch
// the most common cases here and give a useful error
// message.
if(mode == JA_REMOVE_X_JOBS) {
if( mayUserForceRm() == false) {
fprintf( stderr, "Remove aborted. condor_rm -forcex has been disabled by the administrator.\n" );
exit( 1 );
}
}
// Process the args so we do the work.
if( All ) {
handleAll();
} else {
for(i = 0; i < nArgs; i++) {
if( match_prefix( args[i], "-constraint" ) ) {
i++;
addConstraint( args[i] );
} else {
procArg(args[i]);
}
}
}
// Deal with all the -constraint constraints
handleConstraints();
// Finally, do the actual work for all our args which weren't
// constraints...
if( job_ids ) {
CondorError errstack;
ClassAd* result_ad = doWorkByList( job_ids, &errstack );
if (had_error) {
fprintf( stderr, "%s\n", errstack.getFullText(true).c_str() );
}
printNewMessages( result_ad, job_ids );
delete( result_ad );
}
// If releasing jobs, and no errors happened, do a
// reschedule command now.
if ( mode == JA_RELEASE_JOBS && had_error == false ) {
Daemon my_schedd(DT_SCHEDD, NULL, NULL);
CondorError errstack;
if (!my_schedd.sendCommand(RESCHEDULE, Stream::safe_sock, 0, &errstack)) {
fprintf( stderr, "%s\n", errstack.getFullText(true).c_str() );
}
}
return had_error;
}
void
parseArgv( int argc, char* argv[] )
{
int i;
my_name = strdup(argv[0]);
cmd = DRAIN_JOBS;
for( i=1; i<argc; i++ ) {
if( match_prefix( argv[i], "-help" ) ) {
usage(my_name);
}
else if( match_prefix( argv[i], "-version" ) ) {
version();
}
else if( is_dash_arg_prefix( argv[i], "verbose", 4 ) ) {
dash_verbose = 1;
}
else if( match_prefix( argv[i], "-pool" ) ) {
if( i+1 >= argc ) another(argv[i]);
if (pool) {
free(pool);
}
pool = strdup(argv[++i]);
}
else if( match_prefix( argv[i], "-cancel" ) ) {
cmd = CANCEL_DRAIN_JOBS;
}
else if( match_prefix( argv[i], "-fast" ) ) {
how_fast = DRAIN_FAST;
}
else if( match_prefix( argv[i], "-quick" ) ) {
how_fast = DRAIN_QUICK;
}
else if( match_prefix( argv[i], "-graceful" ) ) {
how_fast = DRAIN_GRACEFUL;
}
else if( match_prefix( argv[i], "-resume-on-completion" ) ) {
resume_on_completion = true;
}
else if( match_prefix( argv[i], "-request-id" ) ) {
if( i+1 >= argc ) another(argv[i]);
if (cancel_request_id) {
free(cancel_request_id);
}
cancel_request_id = strdup(argv[++i]);
}
else if( match_prefix( argv[i], "-check" ) ) {
if( i+1 >= argc ) another(argv[i]);
if (draining_check_expr) {
free(draining_check_expr);
}
draining_check_expr = strdup(argv[++i]);
}
else if( argv[i][0] != '-' ) {
break;
}
else {
fprintf(stderr,"ERROR: unexpected argument: %s\n", argv[i]);
exit(2);
}
}
if( i != argc-1 ) {
fprintf(stderr,"ERROR: must specify one target machine\n");
exit(2);
}
target = strdup(argv[i]);
if( cmd == DRAIN_JOBS ) {
if( cancel_request_id ) {
fprintf(stderr,"ERROR: -request-id may only be used with -cancel\n");
exit(2);
}
}
if( cmd == CANCEL_DRAIN_JOBS ) {
if( draining_check_expr ) {
fprintf(stderr,"ERROR: -check may not be used with -cancel\n");
exit(2);
}
}
}
END_TEST
START_TEST(test_match_prefix)
{
ck_assert_int_eq(4, match_prefix("/api", 4, "/api"));
ck_assert_int_eq(3, match_prefix("/a/", 3, "/a/b/c"));
ck_assert_int_eq(-1, match_prefix("/a/", 3, "/ab/c"));
ck_assert_int_eq(4, match_prefix("/*/", 3, "/ab/c"));
ck_assert_int_eq(6, match_prefix("**", 2, "/a/b/c"));
ck_assert_int_eq(2, match_prefix("/*", 2, "/a/b/c"));
ck_assert_int_eq(2, match_prefix("*/*", 3, "/a/b/c"));
ck_assert_int_eq(5, match_prefix("**/", 3, "/a/b/c"));
ck_assert_int_eq(5, match_prefix("**.foo|**.bar", 13, "a.bar"));
ck_assert_int_eq(2, match_prefix("a|b|cd", 6, "cdef"));
ck_assert_int_eq(2, match_prefix("a|b|c?", 6, "cdef"));
ck_assert_int_eq(1, match_prefix("a|?|cd", 6, "cdef"));
ck_assert_int_eq(-1, match_prefix("/a/**.cgi", 9, "/foo/bar/x.cgi"));
ck_assert_int_eq(12, match_prefix("/a/**.cgi", 9, "/a/bar/x.cgi"));
ck_assert_int_eq(5, match_prefix("**/", 3, "/a/b/c"));
ck_assert_int_eq(-1, match_prefix("**/$", 4, "/a/b/c"));
ck_assert_int_eq(5, match_prefix("**/$", 4, "/a/b/"));
ck_assert_int_eq(0, match_prefix("$", 1, ""));
ck_assert_int_eq(-1, match_prefix("$", 1, "x"));
ck_assert_int_eq(1, match_prefix("*$", 2, "x"));
ck_assert_int_eq(1, match_prefix("/$", 2, "/"));
ck_assert_int_eq(-1, match_prefix("**/$", 4, "/a/b/c"));
ck_assert_int_eq(5, match_prefix("**/$", 4, "/a/b/"));
ck_assert_int_eq(0, match_prefix("*", 1, "/hello/"));
ck_assert_int_eq(-1, match_prefix("**.a$|**.b$", 11, "/a/b.b/"));
ck_assert_int_eq(6, match_prefix("**.a$|**.b$", 11, "/a/b.b"));
ck_assert_int_eq(6, match_prefix("**.a$|**.b$", 11, "/a/B.A"));
ck_assert_int_eq(5, match_prefix("**o$", 4, "HELLO"));
}
int
main( int argc, char* argv[] )
{
int i;
param_functions *p_funcs = NULL;
set_mySubSystem( "DAEMON-TOOL", SUBSYSTEM_TYPE_TOOL );
MyName = argv[0];
myDistro->Init( argc, argv );
FILE *input_fp = stdin;
for( i=1; i<argc; i++ ) {
if( match_prefix( argv[i], "-daemontype" ) ) {
if( argv[i + 1] ) {
get_mySubSystem()->setName( argv[++i] );
get_mySubSystem()->setTypeFromName( );
} else {
usage();
}
} else if( match_prefix( argv[i], "-debug" ) ) {
// dprintf to console
Termlog = 1;
p_funcs = get_param_functions();
dprintf_config( "DAEMON-TOOL", p_funcs );
set_debug_flags(NULL, D_FULLDEBUG|D_SECURITY);
} else if( match_prefix( argv[i], "-" ) ) {
usage();
} else {
usage();
}
}
// If we didn't get told what subsystem we should use, set it
// to "TOOL".
if( !get_mySubSystem()->isNameValid() ) {
get_mySubSystem()->setName( "DAEMON-TOOL" );
}
config( 0, true );
IpVerify ipverify;
MyString line;
while( line.readLine(input_fp) ) {
line.chomp();
if( line.IsEmpty() || line[0] == '#' ) {
printf("%s\n",line.Value());
continue;
}
StringList fields(line.Value()," ");
fields.rewind();
char const *perm_str = fields.next();
char const *fqu = fields.next();
char const *ip = fields.next();
char const *expected = fields.next();
MyString sin_str = generate_sinful(ip, 0);
condor_sockaddr addr;
if( !addr.from_sinful(sin_str) ) {
fprintf(stderr,"Invalid ip address: %s\n",ip);
exit(1);
}
DCpermission perm = StringToDCpermission(perm_str);
if( perm == LAST_PERM ) {
fprintf(stderr,"Invalid permission level: %s\n",perm_str);
exit(1);
}
if( strcmp(fqu,"*") == 0 ) {
fqu = "";
}
char const *result;
MyString reason;
if( ipverify.Verify(perm,addr,fqu,&reason,&reason) != USER_AUTH_SUCCESS ) {
result = "DENIED";
}
else {
result = "ALLOWED";
}
if( expected && strcasecmp(expected,result) != 0 ) {
printf("Got wrong result '%s' for '%s': reason: %s!\n",
result,line.Value(),reason.Value());
printf("Aborting.\n");
exit(1);
}
if( expected ) {
printf("%s\n",line.Value());
}
else {
printf("%s %s\n",line.Value(),result);
}
}
}
// Create HalideOpenGLKernel for a piece of GLSL code
static HalideOpenGLKernel *create_kernel(void *user_context, const char *src, int size) {
HalideOpenGLKernel *kernel =
(HalideOpenGLKernel *)malloc(sizeof(HalideOpenGLKernel));
kernel->source = strndup(src, size);
kernel->name = NULL;
kernel->arguments = NULL;
kernel->shader_id = 0;
kernel->program_id = 0;
kernel->next = NULL;
#ifdef DEBUG
halide_printf(user_context, "Compiling GLSL kernel:\n%s\n",
kernel->source);
#endif
// Parse initial comment block
const char *line = kernel->source;
while (*line) {
const char *next_line = strchr(line, '\n') + 1;
if (!next_line)
next_line = line + size;
const char *args;
if ((args = match_prefix(line, kernel_marker))) {
kernel->name = strndup(args, next_line - args - 1);
} else if ((args = match_prefix(line, var_marker))) {
if (HalideOpenGLArgument *arg =
parse_argument(user_context, args, next_line - 1)) {
arg->kind = ARGKIND_VAR;
arg->next = kernel->arguments;
kernel->arguments = arg;
}
} else if ((args = match_prefix(line, input_marker))) {
if (HalideOpenGLArgument *arg =
parse_argument(user_context, args, next_line - 1)) {
arg->kind = ARGKIND_INBUF;
arg->next = kernel->arguments;
kernel->arguments = arg;
}
} else if ((args = match_prefix(line, output_marker))) {
if (HalideOpenGLArgument *arg =
parse_argument(user_context, args, next_line - 1)) {
arg->kind = ARGKIND_OUTBUF;
arg->next = kernel->arguments;
kernel->arguments = arg;
}
} else {
// Stop parsing if we encounter something we don't recognize
break;
}
line = next_line;
}
if (!kernel->name) {
halide_error(user_context, "Internal error: kernel name not specified");
return NULL;
}
// Arguments are currently in reverse order, flip the list.
HalideOpenGLArgument *cur = kernel->arguments;
kernel->arguments = NULL;
while (cur) {
HalideOpenGLArgument *next = cur->next;
cur->next = kernel->arguments;
kernel->arguments = cur;
cur = next;
}
return kernel;
}