/**
* Compares 2 version strings - which is newer.
* - Args 1,3: version strings
* - Arg 2: comparison operator (string)
* - Ret 1: comparison result
*/
static int intf_compare_versions(lua_State* L)
{
char const *v1 = luaL_checkstring(L, 1);
const VERSION_COMP_OP vop = parse_version_op(luaL_checkstring(L, 2));
if(vop == OP_INVALID) return luaL_argerror(L, 2, "unknown version comparison operator - allowed are ==, !=, <, <=, > and >=");
char const *v2 = luaL_checkstring(L, 3);
const bool result = do_version_check(version_info(v1), vop, version_info(v2));
lua_pushboolean(L, result);
return 1;
}
void menu_main()
{
while (1) {
char *options[] = {"Boot CFW",
"Select Patches",
"More options...",
"Version info",
"Power off"};
int result = draw_menu("CakesFW " CAKES_VERSION, 0, sizeof(options) / sizeof(char *), options);
switch (result) {
case 0:
save_config();
boot_cfw();
break;
case 1:
menu_select_patches();
break;
case 2:
menu_more();
break;
case 3:
version_info();
break;
case 4:
i2cWriteRegister(I2C_DEV_MCU, 0x20, 1);
while(1); // Won't break out of this one >:D
}
}
}
void
process_options(int argc, char *argv[]) {
int c;
int index;
char *opt_o_value = NULL;
while( (c = getopt(argc, argv, "hvno:")) != -1 ) {
switch(c) {
case 'h':
help_message();
exit(0);
break;
case 'v':
version_info();
exit(0);
break;
case 'o':
opt_o_value = optarg;
break;
case 'n':
opt_trim = 0; /* disable trimming -- like 454 tools */
break;
case '?':
exit(1);
default:
abort();
}
}
if ( opt_o_value != NULL ) {
strncpy(fastq_file, opt_o_value, FASTQ_FILENAME_MAX_LENGTH);
}
/* process the remaining command line arguments */
for (index = optind; index < argc; index++) {
strncpy(sff_file, argv[index], SFF_FILENAME_MAX_LENGTH);
}
// /* just take the first passed in non-getopt argument as the sff file */
// strncpy(sff_file, argv[optind], SFF_FILENAME_MAX_LENGTH);
/* ensure that a sff file was at least passed in! */
if ( !strlen(sff_file) ) {
fprintf(stderr, "%s %s '%s %s' %s\n",
"[err] Need to specify a sff file!",
"See", PRG_NAME, "-h", "for usage!");
exit(1);
}
}
void surface::free_surface()
{
if(surface_) {
/* Workaround for an SDL bug.
* SDL 2.0.6 frees the blit map unconditionally in SDL_FreeSurface() without checking
* if the reference count has fallen to zero. However, many SDL functions such as
* SDL_ConvertSurface() assume that the blit map is present.
* Thus, we only call SDL_FreeSurface() if this is the last reference to the surface.
* Otherwise we just decrement the reference count ourselves.
*
* - Jyrki, 2017-09-23
*/
if(surface_->refcount > 1 && sdl_get_version() >= version_info(2, 0, 6)) {
--surface_->refcount;
} else {
SDL_FreeSurface(surface_);
}
}
}
int main(int argc, char **argv)
{
int i;
int result = 1;
if(argc == 1) {
version_info();
usage_info();
return EXIT_SUCCESS;
}
for(i=1; i<argc; i++)
if(result)
result = process_file(argv[i]);
if(result)
return EXIT_SUCCESS;
else
return EXIT_FAILURE;
}
void
process_options(int argc, char *argv[]) {
int c;
int index;
char *opt_o_value = NULL;
while( (c = getopt(argc, argv, "hvno:")) != -1 ) {
switch(c) {
case 'h':
help_message();
exit(0);
break;
case 'v':
version_info();
exit(0);
break;
case 'o':
opt_o_value = optarg;
break;
case 'n':
opt_trim = 0; /* disable trimming -- like 454 tools */
break;
case '?':
exit(1);
default:
abort();
}
}
if ( opt_o_value != NULL ) {
strncpy(fastq_file, opt_o_value, FASTQ_FILENAME_MAX_LENGTH);
}
/* process the remaining command line arguments */
for (index = optind; index < argc; index++) {
strncpy(sff_file, argv[index], SFF_FILENAME_MAX_LENGTH);
}
// /* just take the first passed in non-getopt argument as the sff file */
// strncpy(sff_file, argv[optind], SFF_FILENAME_MAX_LENGTH);
}
addon_tracking_info get_addon_tracking_info(const addon_info& addon)
{
const std::string& id = addon.id;
addon_tracking_info t;
t.can_publish = have_addon_pbl_info(id);
t.in_version_control = have_addon_in_vcs_tree(id);
t.installed_version = version_info(0, 0, 0, false);
if(is_addon_installed(id)) {
if(t.can_publish) {
// Try to obtain the version number from the .pbl first.
config pbl;
get_addon_pbl_info(id, pbl);
if(pbl.has_attribute("version")) {
t.installed_version = pbl["version"].str();
}
} else {
// We normally use the _info.cfg version instead.
t.installed_version = get_addon_version_info(id);
}
const version_info& remote_version = addon.version;
if(remote_version == t.installed_version) {
t.state = ADDON_INSTALLED;
} else if(remote_version > t.installed_version) {
t.state = ADDON_INSTALLED_UPGRADABLE;
} else /* if(remote_version < t.installed_version) */ {
t.state = ADDON_INSTALLED_OUTDATED;
}
} else {
t.state = ADDON_NONE;
}
return t;
}
int main (int argc, char **argv) {
int listenfd;
pid_t childpid;
char recvline[MAXLINE + 1];
ssize_t n;
if (argc != 2) {
fprintf(stderr,"usage: %s PORT\n",argv[0]);
fprintf(stderr,"Run FTP server in port PORT\n");
exit(EXIT_FAILURE);
}
if ((listenfd = create_listener(INADDR_ANY, atoi(argv[1]), 1)) == -1) {
perror("create_listener");
exit(EXIT_FAILURE);
}
printf("YAFTPd is running in port %s\n",argv[1]);
for (;;) {
if ((CONN_FD = accept(listenfd, (struct sockaddr *) NULL, NULL)) == -1 ) {
perror("accept");
exit(EXIT_FAILURE);
}
if ((childpid = fork()) == 0) { // Child proccess
printf("Succesful connection at %s. New child PID: %d\n", get_socket_ip(CONN_FD), getpid());
close(listenfd);
/* When the user connects show info message about server version */
char* msg = version_info();
write(CONN_FD, msg, strlen(msg));
while ((n=read(CONN_FD, recvline, MAXLINE)) > 0) {
recvline[n]=0;
printf("PID %d SEND: ", getpid());
if ((fputs(recvline,stdout)) == EOF) {
perror("fputs");
exit(EXIT_FAILURE);
}
int result = parse_command(recvline);
if(result == 1) {
// If parse_command returns 1, we should exit the current
// proccess
exit(EXIT_SUCCESS);
} else if (result == -1) {
// In case of error too, but we should inform the system.
perror("parse_command");
exit(EXIT_FAILURE);
} else {
// If parse_command returns 0, we should continue the
// process.
continue;
}
}
printf("Finished connection with child PID: %d\n", getpid());
} else { // Parent proccess
close(CONN_FD);
}
}
exit(EXIT_SUCCESS);
}
void
parse_command_line(int argc, char *argv[], int spec)
{
const char *arg, *aispec;
char tmpspec[100], tmpargbuf[CLIBUFSIZE], blurb[BLURBSIZE];
int i, n, numused, total_arg_space, tmpargbuflen = 0;
/* This macro just checks that a required next argument is actually
there. */
#define REQUIRE_ONE_ARG \
if (i + 1 >= argc) { \
fprintf(stderr, "Error: `%s' requires an argument, exiting now\n", argv[i]); \
had_error = TRUE; \
continue; \
} \
numused = 2;
/* Each of these causes argument parsing to skip over the option if
it's not the right time to look at it. */
#define GENERAL_OPTION if (spec != general_options) continue;
#define VARIANT_OPTION if (spec != variant_options) continue;
#define PLAYER_OPTION if (spec != player_options) continue;
/* (should peel off any path stuff) */
program_name = argv[0];
if (spec == general_options)
init_options();
total_arg_space = 0;
for (i = 0; i < argc; ++i) {
if (!empty_string(argv[i])) {
strncpy(tmpargbuf, argv[i], CLIBUFSIZE);
tmpargbuf[CLIBUFSIZE - 1] = 0;
tmpargbuflen = strlen(tmpargbuf);
total_arg_space += tmpargbuflen + 2;
(argv[i])[tmpargbuflen] = 0;
}
}
if (args_used == NULL)
args_used = (char *)xmalloc (total_arg_space);
for (i = 1; i < argc; ++i) {
if (argv[i] == NULL || (argv[i])[0] == '\0') {
/* Empty or already munched, nothing to do. */
} else if ((argv[i])[0] == '-') {
arg = argv[i];
Dprintf("%s\n", arg);
numused = 1;
if (strcmp(arg, "-c") == 0) {
REQUIRE_ONE_ARG;
GENERAL_OPTION;
checkpoint_interval = atoi(argv[i+1]);
} else if (strcmp(arg, "-design") == 0) {
GENERAL_OPTION;
#ifdef DESIGNERS
allbedesigners = TRUE;
#else
fprintf(stderr,
"No designing available, ignoring option `%s'\n", arg);
#endif /* DESIGNERS */
} else if (strncmp(arg, "-D", 2) == 0) {
GENERAL_OPTION;
#ifdef DEBUGGING
Debug = TRUE;
if (strchr(arg+2, '-'))
Debug = FALSE;
if (strchr(arg+2, 'M'))
DebugM = TRUE;
if (strchr(arg+2, 'G'))
DebugG = TRUE;
#else
fprintf(stderr,
"No debugging available, ignoring option `%s'\n", arg);
#endif /* DEBUGGING */
} else if (strncmp(arg, "-e", 2) == 0) {
REQUIRE_ONE_ARG;
PLAYER_OPTION;
n = atoi(argv[i+1]);
/* A comma indicates that the name of a particular
desired AI type follows. */
if (strlen(arg) > 2) {
aispec = arg + 2;
if (*aispec != ',') {
sprintf(tmpspec, "%s%s", default_ai_type, aispec);
aispec = tmpspec;
}
} else {
aispec = default_ai_type;
}
while (n-- > 0)
add_a_raw_player_spec(aispec);
} else if (strcmp(arg, "-f") == 0) {
REQUIRE_ONE_ARG;
GENERAL_OPTION;
add_a_module(NULL, argv[i+1]);
} else if (strcmp(arg, "-g") == 0) {
REQUIRE_ONE_ARG;
GENERAL_OPTION;
add_a_module(copy_string(argv[i+1]), NULL);
} else if (strcmp(arg, "-h") == 0) {
REQUIRE_ONE_ARG;
PLAYER_OPTION;
n = atoi(argv[i+1]);
option_num_to_wait_for += n;
while (n-- > 0)
add_a_raw_player_spec("?@");
} else if (strcmp(arg, "-help") == 0) {
GENERAL_OPTION;
help_wanted = TRUE;
/* Will display help info later. */
} else if (strcmp(arg, "-host") == 0) {
REQUIRE_ONE_ARG;
GENERAL_OPTION;
option_game_to_host = copy_string(argv[i+1]);
} else if (strcmp(arg, "-join") == 0) {
REQUIRE_ONE_ARG;
GENERAL_OPTION;
option_game_to_join = copy_string(argv[i+1]);
} else if (strcmp(arg, "-L") == 0) {
REQUIRE_ONE_ARG;
GENERAL_OPTION;
if (strcmp(argv[i+1], "-") == 0)
add_library_path(NULL);
else
add_library_path(argv[i+1]);
} else if (strcmp(arg, "-M") == 0) {
REQUIRE_ONE_ARG;
VARIANT_OPTION;
parse_world_option(argv[i+1]);
} else if (strcmp(arg, "-noai") == 0) {
PLAYER_OPTION;
initially_no_ai = TRUE;
} else if (strcmp(arg, "-r") == 0) {
PLAYER_OPTION;
option_add_default_player = FALSE;
} else if (strcmp(arg, "-R") == 0) {
REQUIRE_ONE_ARG;
GENERAL_OPTION;
#ifdef DEBUGGING
init_xrandom(atoi(argv[i+1]));
#else
fprintf(stderr,
"No debugging available, ignoring option `%s'\n", arg);
#endif /* DEBUGGING */
} else if (strcmp(arg, "-seq") == 0) {
VARIANT_OPTION;
push_key_int_binding(&variant_settings, K_SEQUENTIAL, 1);
} else if (strcmp(arg, "-sim") == 0) {
VARIANT_OPTION;
push_key_int_binding(&variant_settings, K_SEQUENTIAL, 0);
} else if (strncmp(arg, "-t", 2) == 0) {
REQUIRE_ONE_ARG;
VARIANT_OPTION;
parse_realtime_option(arg, argv[i+1]);
} else if (strncmp(arg, "-v", 2) == 0) {
VARIANT_OPTION;
parse_variant(arg + 2);
} else if (strcmp(arg, "-V") == 0) {
VARIANT_OPTION;
push_key_int_binding(&variant_settings, K_SEE_ALL, 1);
} else if (strcmp(arg, "-V0") == 0) {
VARIANT_OPTION;
push_key_int_binding(&variant_settings, K_SEE_ALL, 0);
} else if (strcmp(arg, "-Vfalse") == 0) {
VARIANT_OPTION;
push_key_int_binding(&variant_settings, K_SEE_ALL, 0);
} else if (strcmp(arg, "-w") == 0) {
GENERAL_OPTION;
warnings_suppressed = TRUE;
} else if (strcmp(arg, "-x") == 0) {
GENERAL_OPTION;
option_popup_new_game_dialog = TRUE;
} else if (strcmp(arg, "--help") == 0) {
GENERAL_OPTION;
help_wanted = TRUE;
/* Will display help info later. */
} else if (strcmp(arg, "--version") == 0) {
GENERAL_OPTION;
version_wanted = TRUE;
} else {
numused = 0;
/* Anything unrecognized during the last parse is an error. */
if (spec >= leftover_options) {
fprintf(stderr, "Unrecognized option `%s'\n", arg);
had_error = TRUE;
}
}
if (numused >= 1) {
strcat(args_used, " ");
strcat(args_used, argv[i]);
argv[i] = NULL;
}
if (numused >= 2) {
strcat(args_used, " ");
strcat(args_used, argv[i+1]);
argv[i+1] = NULL;
}
if (numused >= 1)
i += (numused - 1);
} else {
if (spec == player_options) {
if (*(argv[i]) == '+' || *(argv[i]) == '@') {
raw_default_player_spec = argv[i];
} else {
add_a_raw_player_spec(argv[i]);
}
strcat(args_used, " ");
strcat(args_used, argv[i]);
argv[i] = NULL;
}
}
}
if (version_wanted) {
version_info();
}
if (had_error || help_wanted || variant_help_wanted) {
/* If we want to get help about a particular game, have to
load it first. */
if (help_wanted || variant_help_wanted)
load_all_modules();
if (had_error || help_wanted)
general_usage_info();
if (had_error || help_wanted)
player_usage_info();
if (help_wanted && mainmodule != NULL) {
printf("\nGame info:\n\n");
if (!empty_string(mainmodule->title))
printf("%s (%s)\n", mainmodule->title, mainmodule->name);
else
printf("%s\n", mainmodule->name);
printf(" \n");
if (mainmodule->blurb != lispnil) {
append_blurb_strings(blurb, mainmodule->blurb);
printf("%s", blurb);
} else {
printf("(no description)");
}
}
/* Display variant info here so it comes after basic info
about the game module. */
if (had_error || help_wanted || variant_help_wanted)
game_usage_info();
}
if (had_error || help_wanted || variant_help_wanted || version_wanted) {
exit(had_error);
}
}
static void parse_long_options(int *argc, char ***argv)
{
int c, option_index = 0, n = 1;
const char *args = "d:hv";
#ifdef HAVE_GETOPT_H
static struct option long_options[] = {
{"version", 0, 0, 0},
{"help", 0, 0, 0},
{0, 0, 0, 0}
};
#endif
while (1) {
opterr = 0;
#ifdef HAVE_GETOPT_H
c = getopt_long(*argc, *argv, args, long_options, &option_index);
#else
c = getopt(*argc, *argv, args);
#endif
if (c == -1)
break;
if (((char) c) == '?')
break;
switch (c) {
case 0:
switch (option_index) {
case 0:
printf("%s", version_info());
exit(0);
case 1:
usage();
exit(0);
default:
break;
}
break;
case 'v':
printf("%s", version_info());
exit(0);
case 'd':
debugger_path = strdup(optarg);
if (optarg == (*argv)[n + 1]) {
/* optarg is in next argv (-d foo) */
n += 2;
} else {
/* optarg is in this argv (-dfoo) */
n++;
}
break;
case 'h':
usage();
exit(0);
default:
break;
}
}
*argc -= n;
*argv += n;
if (**argv && strcmp(**argv, "--") == 0) {
(*argc)--;
(*argv)++;
}
}
int main(int argc, const char **argv)
{
struct stat st;
iconv_t ic;
STRBUF *wbuf;
STRBUF *docbuf;
STRBUF *outbuf;
int i = 1;
(void)setlocale(LC_ALL, "");
while (argv[i]) {
if (!strcmp(argv[i], "--raw")) {
opt_raw = 1;
i++; continue;
} else if (!strcmp(argv[i], "--raw-input")) {
opt_raw_input = 1;
i++; continue;
} else if (!strncmp(argv[i], "--encoding=", 11)) {
size_t arglen = strlen(argv[i]) - 10;
#ifdef iconvlist
if (!strcmp(argv[i] + 11, "list")) {
show_iconvlist();
}
#endif
opt_encoding = ymalloc(arglen);
memcpy(opt_encoding, argv[i] + 11, arglen);
i++; continue;
} else if (!strncmp(argv[i], "--width=", 8)) {
opt_width = atoi(argv[i] + 8);
if(opt_width < 3 && opt_width != -1) {
fprintf(stderr, "Invalid value for width: %s\n",
argv[i] + 8);
exit(EXIT_FAILURE);
}
i++; continue;
} else if (!strcmp(argv[i], "--force")) {
// ignore this setting
i++; continue;
} else if (!strncmp(argv[i], "--output=", 9)) {
if (*(argv[i] + 9) != '-') {
size_t arglen = strlen(argv[i]) - 8;
opt_output = ymalloc(arglen);
memcpy(opt_output, argv[i] + 9, arglen);
}
i++; continue;
} else if (!strncmp(argv[i], "--subst=", 8)) {
if (!strcmp(argv[i] + 8, "none"))
opt_subst = SUBST_NONE;
else if (!strcmp(argv[i] + 8, "some"))
opt_subst = SUBST_SOME;
else if (!strcmp(argv[i] + 8, "all"))
opt_subst = SUBST_ALL;
else {
fprintf(stderr, "Invalid value for --subst: %s\n",
argv[i] + 8);
exit(EXIT_FAILURE);
}
i++; continue;
} else if (!strcmp(argv[i], "--help")) {
usage();
} else if (!strcmp(argv[i], "--version")
|| !strcmp(argv[i], "-v")) {
version_info();
} else if (!strcmp(argv[i], "-")) {
usage();
} else {
if(opt_filename)
usage();
opt_filename = argv[i];
i++; continue;
}
}
if(opt_encoding && !strcmp("show", opt_encoding)) {
yfree(opt_encoding);
opt_encoding = guess_encoding();
printf("%s\n", opt_encoding);
yfree(opt_encoding);
exit(EXIT_SUCCESS);
}
if(opt_raw)
opt_width = -1;
if(!opt_filename)
usage();
if(!opt_encoding) {
opt_encoding = guess_encoding();
}
ic = init_conv("UTF-8", opt_encoding);
if (0 != stat(opt_filename, &st)) {
fprintf(stderr, "%s: %s\n",
opt_filename, strerror(errno));
exit(EXIT_FAILURE);
}
/* read content.xml */
docbuf = opt_raw_input ?
read_from_xml(opt_filename, "content.xml") :
read_from_zip(opt_filename, "content.xml");
if (!opt_raw) {
subst_doc(ic, docbuf);
format_doc(docbuf, opt_raw_input);
}
wbuf = wrap(docbuf, opt_width);
/* remove all trailing whitespace */
(void) regex_subst(wbuf, " +\n", _REG_GLOBAL, "\n");
outbuf = conv(ic, wbuf);
if (opt_output)
write_to_file(outbuf, opt_output);
else
fwrite(strbuf_get(outbuf), strbuf_len(outbuf), 1, stdout);
finish_conv(ic);
strbuf_free(wbuf);
strbuf_free(docbuf);
strbuf_free(outbuf);
#ifndef NO_ICONV
yfree(opt_encoding);
#endif
if (opt_output)
yfree(opt_output);
return EXIT_SUCCESS;
}
void
doContactSchedd()
{
if (command_queue.IsEmpty()) {
daemonCore->Reset_Timer( contactScheddTid, contact_schedd_interval ); // Come back in a min
return;
}
dprintf(D_FULLDEBUG,"in doContactSchedd\n");
SchedDRequest * current_command = NULL;
int error=FALSE;
std::string error_msg;
CondorError errstack;
bool do_reschedule = false;
int failure_line_num = 0;
int failure_errno = 0;
// Try connecting to schedd
DCSchedd dc_schedd ( ScheddAddr, ScheddPool );
if (dc_schedd.error() || !dc_schedd.locate()) {
sprintf( error_msg, "Error locating schedd %s", ScheddAddr );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
// If you can't connect return "Failure" on every job request
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command == SchedDRequest::SDC_STATUS_CONSTRAINED) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str(),
"0"};
enqueue_result (current_command->request_id, result, 3);
} else if (current_command->command == SchedDRequest::SDC_SUBMIT_JOB) {
const char * result[] = {
GAHP_RESULT_FAILURE,
NULL,
error_msg.c_str() };
enqueue_result (current_command->request_id, result, 3);
} else if (current_command->command == SchedDRequest::SDC_UPDATE_LEASE) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str(),
NULL };
enqueue_result (current_command->request_id, result, 3);
} else {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str() };
enqueue_result (current_command->request_id, result, 2);
}
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
}
SchedDRequest::schedd_command_type commands [] = {
SchedDRequest::SDC_REMOVE_JOB,
SchedDRequest::SDC_HOLD_JOB,
SchedDRequest::SDC_RELEASE_JOB };
const char * command_titles [] = {
"REMOVE_JOB", "HOLD_JOB", "RELEASE_JOB" };
// REMOVE
// HOLD
// RELEASE
int i=0;
while (i<3) {
StringList id_list;
SimpleList <SchedDRequest*> this_batch;
SchedDRequest::schedd_command_type this_command = commands[i];
const char * this_action = command_titles[i];
const char * this_reason = NULL;
dprintf (D_FULLDEBUG, "Processing %s requests\n", this_action);
error = FALSE;
// Create a batch of commands with the same command type AND the same reason
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != this_command)
continue;
if ((this_reason != NULL) && (strcmp (current_command->reason, this_reason) != 0))
continue;
if (this_reason == NULL)
this_reason = current_command->reason;
char job_id_buff[30];
sprintf (job_id_buff, "%d.%d",
current_command->cluster_id,
current_command->proc_id);
id_list.append (job_id_buff);
this_batch.Append (current_command);
}
// If we haven't found any....
if (id_list.isEmpty()) {
i++;
continue; // ... then try the next command
}
// Perform the appropriate command on the current batch
ClassAd * result_ad= NULL;
if (this_command == SchedDRequest::SDC_REMOVE_JOB) {
errstack.clear();
result_ad=
dc_schedd.removeJobs (
&id_list,
this_reason,
&errstack);
} else if (this_command == SchedDRequest::SDC_HOLD_JOB) {
errstack.clear();
result_ad=
dc_schedd.holdJobs (
&id_list,
this_reason,
NULL,
&errstack);
} else if (this_command == SchedDRequest::SDC_RELEASE_JOB) {
errstack.clear();
result_ad=
dc_schedd.releaseJobs (
&id_list,
this_reason,
&errstack);
} else {
EXCEPT( "Unexpected command type %d in doContactSchedd",
this_command );
}
// Analyze the result ad
if (!result_ad) {
error = TRUE;
sprintf( error_msg, "Error connecting to schedd %s %s: %s",
ScheddAddr, dc_schedd.addr(), errstack.getFullText() );
}
else {
result_ad->dPrint (D_FULLDEBUG);
if ( this_command == SchedDRequest::SDC_RELEASE_JOB ) {
do_reschedule = true;
}
}
// Go through the batch again, and create responses for each request
this_batch.Rewind();
while (this_batch.Next(current_command)) {
// Check the result
char job_id_buff[30];
if (result_ad && (error == FALSE)) {
sprintf (job_id_buff, "job_%d_%d",
current_command->cluster_id,
current_command->proc_id);
int remove_result;
if (result_ad->LookupInteger (job_id_buff, remove_result)) {
switch (remove_result) {
case AR_ERROR:
error = TRUE;
error_msg = "General Error";
break;
case AR_SUCCESS:
error = FALSE;
break;
case AR_NOT_FOUND:
error = TRUE;
error_msg = "Job not found";
break;
case AR_BAD_STATUS:
error = TRUE;
error_msg = "Bad job status";
break;
case AR_ALREADY_DONE:
error = TRUE;
error_msg = "Already done";
break;
case AR_PERMISSION_DENIED:
error = TRUE;
error_msg = "Permission denied";
break;
default:
error = TRUE;
error_msg = "Unknown Result";
} // hctiws
} else {
error_msg = "Unable to get result";
} // fi lookup result for job
} // fi error == FALSE
if (error) {
dprintf (D_ALWAYS, "Error (operation: %s) %d.%d: %s\n",
this_action,
current_command->cluster_id,
current_command->proc_id,
error_msg.c_str());
const char * result[2];
result[0] = GAHP_RESULT_FAILURE;
result[1] = error_msg.c_str();
enqueue_result (current_command->request_id, result, 2);
} else {
dprintf (D_ALWAYS, "Succeess (operation: %s) %d.%d\n",
this_action,
current_command->cluster_id,
current_command->proc_id);
const char * result[2];
result[0] = GAHP_RESULT_SUCCESS;
result[1] = NULL;
enqueue_result (current_command->request_id, result, 2);
} // fi error
// Mark the status
current_command->status = SchedDRequest::SDCS_COMPLETED;
} // elihw this_batch
if ( result_ad ) {
delete result_ad;
}
}
dprintf (D_FULLDEBUG, "Processing JOB_STAGE_IN requests\n");
// JOB_STAGE_IN
int MAX_BATCH_SIZE=1; // This should be a config param
SimpleList <SchedDRequest*> stage_in_batch;
do {
stage_in_batch.Clear();
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_JOB_STAGE_IN)
continue;
dprintf (D_ALWAYS, "Adding %d.%d to STAGE_IN batch\n",
current_command->cluster_id,
current_command->proc_id);
stage_in_batch.Append (current_command);
if (stage_in_batch.Number() >= MAX_BATCH_SIZE)
break;
}
if (stage_in_batch.Number() > 0) {
ClassAd ** array = new ClassAd*[stage_in_batch.Number()];
i=0;
stage_in_batch.Rewind();
while (stage_in_batch.Next(current_command)) {
array[i++] = current_command->classad;
}
error = FALSE;
errstack.clear();
if (!dc_schedd.spoolJobFiles( stage_in_batch.Number(),
array,
&errstack )) {
error = TRUE;
sprintf( error_msg, "Error sending files to schedd %s: %s", ScheddAddr, errstack.getFullText() );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
}
delete [] array;
stage_in_batch.Rewind();
while (stage_in_batch.Next(current_command)) {
current_command->status = SchedDRequest::SDCS_COMPLETED;
if (error) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str() };
enqueue_result (current_command->request_id, result, 2);
} else {
const char * result[] = {
GAHP_RESULT_SUCCESS,
NULL };
enqueue_result (current_command->request_id, result, 2);
}
} // elihw (command_queue)
} // fi has STAGE_IN requests
} while (stage_in_batch.Number() > 0);
dprintf (D_FULLDEBUG, "Processing JOB_STAGE_OUT requests\n");
// JOB_STAGE_OUT
SimpleList <SchedDRequest*> stage_out_batch;
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_JOB_STAGE_OUT)
continue;
stage_out_batch.Append (current_command);
}
if (stage_out_batch.Number() > 0) {
std::string constraint = "";
stage_out_batch.Rewind();
int jobsexpected = stage_out_batch.Number();
while (stage_out_batch.Next(current_command)) {
sprintf_cat( constraint, "(ClusterId==%d&&ProcId==%d)||",
current_command->cluster_id,
current_command->proc_id );
}
constraint += "False";
error = FALSE;
errstack.clear();
int jobssent;
if (!dc_schedd.receiveJobSandbox( constraint.c_str(),
&errstack, &jobssent )) {
error = TRUE;
sprintf( error_msg, "Error receiving files from schedd %s: %s",
ScheddAddr, errstack.getFullText() );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
}
if(error == FALSE && jobssent != jobsexpected) {
error = TRUE;
sprintf( error_msg, "Schedd %s didn't send expected files",
ScheddAddr );
dprintf (D_ALWAYS, "Transfered files for %d jobs but got files for %d jobs. (Schedd %s with contraint %s\n", jobsexpected, jobssent, ScheddAddr, constraint.c_str());
}
stage_out_batch.Rewind();
while (stage_out_batch.Next(current_command)) {
current_command->status = SchedDRequest::SDCS_COMPLETED;
if (error) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str() };
enqueue_result (current_command->request_id, result, 2);
} else {
const char * result[] = {
GAHP_RESULT_SUCCESS,
NULL };
enqueue_result (current_command->request_id, result, 2);
}
} // elihw (command_queue)
} // fi has STAGE_OUT requests
dprintf (D_FULLDEBUG, "Processing JOB_REFRESH_PROXY requests\n");
CondorVersionInfo ver_info(dc_schedd.version());
bool delegate_credential;
if ( ver_info.built_since_version(6,7,19) &&
param_boolean( "DELEGATE_JOB_GSI_CREDENTIALS", true ) ) {
delegate_credential = true;
} else {
delegate_credential = false;
}
// JOB_REFRESH_PROXY
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_JOB_REFRESH_PROXY)
continue;
time_t expiration_time = GetDesiredDelegatedJobCredentialExpiration(current_command->classad);
time_t result_expiration_time = 0;
bool result;
errstack.clear();
if ( delegate_credential ) {
result = dc_schedd.delegateGSIcredential(
current_command->cluster_id,
current_command->proc_id,
current_command->proxy_file,
expiration_time,
&result_expiration_time,
&errstack );
// Currently, we do not propagate the actual resulting
// expiration time back to the gridmanager. We
// probably should.
} else {
result = dc_schedd.updateGSIcredential(
current_command->cluster_id,
current_command->proc_id,
current_command->proxy_file,
&errstack );
}
current_command->status = SchedDRequest::SDCS_COMPLETED;
if (result == false) {
sprintf( error_msg, "Error refreshing proxy to schedd %s: %s",
ScheddAddr, errstack.getFullText() );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
const char * result_to_queue[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str() };
enqueue_result (current_command->request_id, result_to_queue, 2);
} else {
const char * result_to_queue[] = {
GAHP_RESULT_SUCCESS,
NULL };
enqueue_result (current_command->request_id, result_to_queue, 2);
}
}
// Now do all the QMGMT transactions
error = FALSE;
// Try connecting to the queue
Qmgr_connection * qmgr_connection;
if ((qmgr_connection = ConnectQ(dc_schedd.addr(), QMGMT_TIMEOUT, false, NULL, NULL, dc_schedd.version() )) == NULL) {
error = TRUE;
sprintf( error_msg, "Error connecting to schedd %s", ScheddAddr );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
} else {
errno = 0;
AbortTransaction(); // Just so we can call BeginTransaction() in the loop
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
}
dprintf (D_FULLDEBUG, "Processing UPDATE_CONSTRAINED/UDATE_JOB requests\n");
// UPDATE_CONSTRAINED
// UDATE_JOB
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if ((current_command->command != SchedDRequest::SDC_UPDATE_CONSTRAINED) &&
(current_command->command != SchedDRequest::SDC_UPDATE_JOB))
continue;
if (qmgr_connection == NULL)
goto update_report_result;
error = FALSE;
errno = 0;
BeginTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
current_command->classad->ResetExpr();
ExprTree *tree;
const char *lhstr, *rhstr;
while( current_command->classad->NextExpr(lhstr, tree) ) {
rhstr = ExprTreeToString( tree );
if( !lhstr || !rhstr) {
sprintf( error_msg, "ERROR: ClassAd problem in Updating by constraint %s",
current_command->constraint );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
} else {
if (current_command->command == SchedDRequest::SDC_UPDATE_CONSTRAINED) {
if( SetAttributeByConstraint(current_command->constraint,
lhstr,
rhstr) == -1 ) {
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
sprintf( error_msg, "ERROR: Failed (errno=%d) to SetAttributeByConstraint %s=%s for constraint %s",
errno, lhstr, rhstr, current_command->constraint );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
}
} else if (current_command->command == SchedDRequest::SDC_UPDATE_JOB) {
if( SetAttribute(current_command->cluster_id,
current_command->proc_id,
lhstr,
rhstr) == -1 ) {
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
sprintf( error_msg, "ERROR: Failed to SetAttribute() %s=%s for job %d.%d",
lhstr, rhstr, current_command->cluster_id, current_command->proc_id);
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
}
}
}
if (error)
break;
} // elihw classad
update_report_result:
if (error) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str() };
//RemoteCommitTransaction();
enqueue_result (current_command->request_id, result, 2);
current_command->status = SchedDRequest::SDCS_COMPLETED;
if ( qmgr_connection != NULL ) {
errno = 0;
AbortTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
}
} else {
if ( RemoteCommitTransaction() < 0 ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
const char * result[] = {
GAHP_RESULT_SUCCESS,
NULL };
enqueue_result (current_command->request_id, result, 2);
current_command->status = SchedDRequest::SDCS_COMPLETED;
} // fi
} // elihw
dprintf (D_FULLDEBUG, "Processing UPDATE_LEASE requests\n");
// UPDATE_LEASE
command_queue.Rewind();
while (command_queue.Next(current_command)) {
error = FALSE;
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_UPDATE_LEASE)
continue;
std::string success_job_ids="";
if (qmgr_connection == NULL) {
sprintf( error_msg, "Error connecting to schedd %s", ScheddAddr );
error = TRUE;
} else {
error = FALSE;
errno = 0;
BeginTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
for (i=0; i<current_command->num_jobs; i++) {
time_t time_now = time(NULL);
int duration =
current_command->expirations[i].expiration - time_now;
dprintf (D_FULLDEBUG,
"Job %d.%d SetTimerAttribute=%d\n",
current_command->expirations[i].cluster,
current_command->expirations[i].proc,
duration);
if (SetTimerAttribute (current_command->expirations[i].cluster,
current_command->expirations[i].proc,
ATTR_TIMER_REMOVE_CHECK,
duration) < 0) {
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
dprintf (D_ALWAYS,
"Unable to SetTimerAttribute(%d, %d), errno=%d\n",
current_command->expirations[i].cluster,
current_command->expirations[i].proc,
errno);
} else {
// Append job id to the result line
if (success_job_ids.length() > 0)
success_job_ids += ",";
sprintf_cat( success_job_ids,
"%d.%d",
current_command->expirations[i].cluster,
current_command->expirations[i].proc);
}
} //rof jobs for request
} // fi error
if (error) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str(),
NULL
};
//RemoteCommitTransaction();
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
if ( qmgr_connection != NULL ) {
errno = 0;
AbortTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
}
} else {
if ( RemoteCommitTransaction() < 0 ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
const char * result[] = {
GAHP_RESULT_SUCCESS,
NULL,
success_job_ids.length()?success_job_ids.c_str():NULL
};
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
} // fi
} // elihw UPDATE_LEASE requests
dprintf (D_FULLDEBUG, "Processing SUBMIT_JOB requests\n");
// SUBMIT_JOB
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_SUBMIT_JOB)
continue;
int ClusterId = -1;
int ProcId = -1;
if (qmgr_connection == NULL) {
error = TRUE;
goto submit_report_result;
}
errno = 0;
BeginTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
error = FALSE;
if ((ClusterId = NewCluster()) >= 0) {
ProcId = NewProc (ClusterId);
}
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
if ( ClusterId < 0 ) {
error = TRUE;
error_msg = "Unable to create a new job cluster";
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
} else if ( ProcId < 0 ) {
error = TRUE;
error_msg = "Unable to create a new job proc";
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
}
if ( ClusterId == -2 || ProcId == -2 ) {
error = TRUE;
error_msg =
"Number of submitted jobs would exceed MAX_JOBS_SUBMITTED\n";
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
}
// Adjust the argument/environment syntax based on the version
// of the schedd we are talking to.
if( error == FALSE) {
CondorVersionInfo version_info(dc_schedd.version());
ArgList arglist;
MyString arg_error_msg;
Env env_obj;
MyString env_error_msg;
if(!arglist.AppendArgsFromClassAd(current_command->classad,&arg_error_msg) ||
! arglist.InsertArgsIntoClassAd(current_command->classad,&version_info,&arg_error_msg))
{
sprintf( error_msg,
"ERROR: ClassAd problem in converting arguments to syntax "
"for schedd (version=%s): %s\n",
dc_schedd.version() ? dc_schedd.version() : "NULL",
arg_error_msg.Value());
dprintf( D_ALWAYS,"%s\n", error_msg.c_str() );
error = TRUE;
}
if(!env_obj.MergeFrom(current_command->classad,&env_error_msg) ||
!env_obj.InsertEnvIntoClassAd(current_command->classad,&env_error_msg,NULL,&version_info))
{
sprintf( error_msg,
"ERROR: Failed to convert environment to target syntax"
" for schedd (version %s): %s\n",
dc_schedd.version() ? dc_schedd.version() : "NULL",
env_error_msg.Value());
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
}
}
if( error == FALSE ) {
// See the comment in the function body of ExpandInputFileList
// for an explanation of what is going on here.
MyString transfer_input_error_msg;
if( !FileTransfer::ExpandInputFileList( current_command->classad, transfer_input_error_msg ) ) {
dprintf( D_ALWAYS, "%s\n", transfer_input_error_msg.Value() );
error = TRUE;
}
}
if ( error == FALSE ) {
current_command->classad->Assign(ATTR_CLUSTER_ID, ClusterId);
current_command->classad->Assign(ATTR_PROC_ID, ProcId);
// Special case for the job lease
int expire_time;
if ( current_command->classad->LookupInteger( ATTR_TIMER_REMOVE_CHECK, expire_time ) ) {
if ( SetTimerAttribute( ClusterId, ProcId,
ATTR_TIMER_REMOVE_CHECK,
expire_time - time(NULL) ) == -1 ) {
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
sprintf( error_msg, "ERROR: Failed to SetTimerAttribute %s=%ld for job %d.%d",
ATTR_TIMER_REMOVE_CHECK, expire_time - time(NULL), ClusterId, ProcId );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
goto submit_report_result;
}
current_command->classad->Delete( ATTR_TIMER_REMOVE_CHECK );
}
// Set all the classad attribute on the remote classad
current_command->classad->ResetExpr();
ExprTree *tree;
const char *lhstr, *rhstr;
while( current_command->classad->NextExpr(lhstr, tree) ) {
rhstr = ExprTreeToString( tree );
if( !lhstr || !rhstr) {
sprintf( error_msg, "ERROR: ClassAd problem in Updating by constraint %s",
current_command->constraint );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
} else if( SetAttribute (ClusterId, ProcId,
lhstr,
rhstr) == -1 ) {
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
sprintf( error_msg, "ERROR: Failed to SetAttribute %s=%s for job %d.%d",
lhstr, rhstr, ClusterId, ProcId );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
}
if (error) break;
} // elihw classad
} // fi error==FALSE
submit_report_result:
char job_id_buff[30];
sprintf (job_id_buff, "%d.%d", ClusterId, ProcId);
if (error) {
const char * result[] = {
GAHP_RESULT_FAILURE,
job_id_buff,
error_msg.c_str() };
enqueue_result (current_command->request_id, result, 3);
if ( qmgr_connection != NULL ) {
errno = 0;
AbortTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
}
current_command->status = SchedDRequest::SDCS_COMPLETED;
} else {
if ( RemoteCommitTransaction() < 0 ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
const char * result[] = {
GAHP_RESULT_SUCCESS,
job_id_buff,
NULL };
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
} // elihw
dprintf (D_FULLDEBUG, "Processing STATUS_CONSTRAINED requests\n");
// STATUS_CONSTRAINED
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_STATUS_CONSTRAINED)
continue;
if (qmgr_connection != NULL) {
SimpleList <MyString *> matching_ads;
error = FALSE;
ClassAd *next_ad;
ClassAdList adlist;
// Only use GetAllJobsByConstraint if remote schedd is
// 6.9.5 or newer. Previous versions either did not
// support this call, or they closed the Qmgmt connection
// as a side-effect of this call.
if( ver_info.built_since_version(6,9,5) ) {
dprintf( D_FULLDEBUG, "Calling GetAllJobsByConstraint(%s)\n",
current_command->constraint );
// NOTE: this could be made more efficient if we knew
// the list of attributes to query. For lack of that,
// we just get all attributes.
GetAllJobsByConstraint( current_command->constraint, "", adlist);
}
else {
// This is the old latency-prone method.
dprintf( D_FULLDEBUG, "Calling GetNextJobByConstraint(%s)\n",
current_command->constraint );
next_ad = GetNextJobByConstraint( current_command->constraint, 1 );
while( next_ad != NULL ) {
adlist.Insert( next_ad );
next_ad = GetNextJobByConstraint( current_command->constraint, 0 );
}
}
// NOTE: ClassAdList will deallocate the ClassAds in it
adlist.Rewind();
while( (next_ad=adlist.Next()) ) {
MyString * da_buffer = new MyString(); // Use a ptr to avoid excessive copying
if ( useXMLClassads ) {
ClassAdXMLUnparser unparser;
unparser.SetUseCompactSpacing(true);
unparser.Unparse (next_ad, *da_buffer);
} else {
NewClassAdUnparser unparser;
unparser.SetUseCompactSpacing(true);
unparser.Unparse (next_ad, *da_buffer);
}
matching_ads.Append (da_buffer);
}
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
// now output this list of classads into a result
const char ** result = new const char* [matching_ads.Length() + 3];
std::string _ad_count;
sprintf( _ad_count, "%d", matching_ads.Length() );
int count=0;
result[count++] = GAHP_RESULT_SUCCESS;
result[count++] = NULL;
result[count++] = _ad_count.c_str();
MyString *next_string;
matching_ads.Rewind();
while (matching_ads.Next(next_string)) {
result[count++] = next_string->Value();
}
enqueue_result (current_command->request_id, result, count);
current_command->status = SchedDRequest::SDCS_COMPLETED;
// Cleanup
matching_ads.Rewind();
while (matching_ads.Next(next_string)) {
delete next_string;
}
//CommitTransaction();
delete [] result;
}
else {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str(),
"0" };
//RemoteCommitTransaction();
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
} //elihw
contact_schedd_disconnect:
if ( qmgr_connection != NULL ) {
DisconnectQ (qmgr_connection, FALSE);
}
if ( failure_line_num ) {
// We had an error talking to the schedd. Take all of our
// incomplete commands and mark them as failed.
// TODO Consider retrying these commands, rather than
// immediately marking them as failed.
if ( failure_errno == ETIMEDOUT ) {
dprintf( D_ALWAYS, "Timed out talking to schedd at line %d in "
"doContactSchedd()\n", failure_line_num );
sprintf( error_msg, "Timed out talking to schedd" );
} else {
dprintf( D_ALWAYS, "Error talking to schedd at line %d in "
"doContactSchedd(), errno=%d (%s)\n", failure_line_num,
failure_errno, strerror(failure_errno) );
sprintf( error_msg, "Error talking to schedd" );
}
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if ( current_command->status != SchedDRequest::SDCS_NEW ) {
continue;
}
switch( current_command->command ) {
case SchedDRequest::SDC_UPDATE_JOB:
case SchedDRequest::SDC_UPDATE_CONSTRAINED:
{
const char *result[2] = { GAHP_RESULT_FAILURE, error_msg.c_str() };
enqueue_result (current_command->request_id, result, 2);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
break;
case SchedDRequest::SDC_UPDATE_LEASE:
{
const char *result[3] = { GAHP_RESULT_FAILURE, error_msg.c_str(), NULL };
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
break;
case SchedDRequest::SDC_SUBMIT_JOB:
{
const char *result[3] = { GAHP_RESULT_FAILURE, "-1.-1", error_msg.c_str() };
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
break;
case SchedDRequest::SDC_STATUS_CONSTRAINED:
{
const char *result[3] = { GAHP_RESULT_FAILURE, error_msg.c_str(), "0" };
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
break;
default:
// Do nothing
;
}
}
}
if ( do_reschedule ) {
dc_schedd.reschedule();
}
// Write all of our results to our parent.
flush_results();
dprintf (D_FULLDEBUG, "Finishing doContactSchedd()\n");
// Clean up the list
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status == SchedDRequest::SDCS_COMPLETED) {
command_queue.DeleteCurrent();
delete current_command;
}
}
// Come back soon..
// QUESTION: Should this always be a fixed time period?
daemonCore->Reset_Timer( contactScheddTid, contact_schedd_interval );
}
int main(int argc, char *argv[]) {
int c;
const char* normal_sample_id = _default_normal_sample_id;
const char* tumor_sample_id = _default_tumor_sample_id;
const char *fn_fa = 0;
pu_data2_t *d = (pu_data2_t*)calloc(1, sizeof(pu_data2_t));
d->min_somatic_qual=15;
d->tid = -1; d->mask = BAM_DEF_MASK; d->mapQ = 0;
d->c = sniper_maqcns_init();
int use_priors = 1;
d->include_loh = 1;
d->include_gor = 1;
d->use_joint_priors = 0;
d->somatic_mutation_rate = 0.01;
const char *output_format = "classic";
while ((c = getopt(argc, argv, "n:t:vf:T:N:r:I:q:Q:pLGJs:F:")) >= 0) {
switch (c) {
case 'f': fn_fa = optarg; break;
case 'T': d->c->theta = atof(optarg); break;
case 'N': d->c->n_hap = atoi(optarg); break;
case 'r': d->c->het_rate = atof(optarg); break;
case 'q': d->mapQ = atoi(optarg); break;
case 'Q': d->min_somatic_qual = atoi(optarg); break;
case 'F': output_format = optarg; break;
case 'p': use_priors = 0; break;
case 'J': d->use_joint_priors = 1; break;
case 's': d->somatic_mutation_rate = atof(optarg); d->use_joint_priors = 1; break;
case 'v': version_info(); exit(0); break;
case 't': tumor_sample_id = optarg; break;
case 'n': normal_sample_id = optarg; break;
case 'L': d->include_loh = 0; break;
case 'G': d->include_gor = 0; break;
default: fprintf(stderr, "Unrecognizd option '-%c'.\n", c); return 1;
}
}
if (optind == argc) {
usage(argv[0], d);
sniper_maqcns_destroy(d->c); free(d);
return 1;
}
if (fn_fa) {
d->fai = fai_load(fn_fa);
}
else {
fprintf(stderr, "You MUST specify a reference sequence. It isn't optional.\n");
sniper_maqcns_destroy(d->c);
free(d);
exit(1);
}
if(d->use_joint_priors) {
fprintf(stderr,"Using priors accounting for somatic mutation rate. Prior probability of a somatic mutation is %f\n",d->somatic_mutation_rate);
make_joint_prior(d->somatic_mutation_rate);
}
sniper_maqcns_prepare(d->c);
fprintf(stderr,"Preparing to snipe some somatics\n");
if(use_priors) {
fprintf(stderr,"Using prior probabilities\n");
makeSoloPrior();
}
bamFile fp1, fp2;
qAddTableInit();
fp1 = (strcmp(argv[optind], "-") == 0)? bam_dopen(fileno(stdin), "r") : bam_open(argv[optind], "r");
fprintf(stderr, "Normal bam is %s\n", argv[optind+1]);
fprintf(stderr, "Tumor bam is %s\n", argv[optind]);
d->h1 = bam_header_read(fp1);
sam_header_parse_rg(d->h1);
fp2 = bam_open(argv[optind+1], "r");
d->h2 = bam_header_read(fp2);
sam_header_parse_rg(d->h2);
FILE* snp_fh = fopen(argv[optind+2], "w");
/* this will exit if the format name is invalid */
output_formatter_t fmt = output_formatter_create(output_format, snp_fh);
d->output_formatter = &fmt;
if(snp_fh) {
header_data_t hdr;
hdr.refseq = fn_fa;
hdr.normal_sample_id = normal_sample_id;
hdr.tumor_sample_id = tumor_sample_id;
d->output_formatter->header_fn(snp_fh, &hdr);
bam_sspileup_file(fp1, fp2, d->mask, d->mapQ, glf_somatic, d, snp_fh);
}
else {
fprintf(stderr, "Unable to open snp file!!!!!!!!!\n");
exit(1);
}
bam_close(fp1);
bam_close(fp2);
bam_header_destroy(d->h1);
bam_header_destroy(d->h2);
if (d->fai) fai_destroy(d->fai);
sniper_maqcns_destroy(d->c);
free(d->ref); free(d);
fclose(snp_fh);
return 0;
}
int main (int argc, char **argv)
{
int ret = 0;
version_info ();
if (argc < 2)
{
dt_info ("", " no enough args\n");
show_usage ();
return 0;
}
memset(&ply_ctx,0,sizeof(ply_ctx_t));
ply_ctx.disp_width = 720;
ply_ctx.disp_height = 480;
player_register_all();
register_ex_all();
dtplayer_para_t para;
parse_cmd(argc,argv,¶);
void *player_priv = dtplayer_init (¶);
if (!player_priv)
return -1;
//get media info
dt_media_info_t info;
ret = dtplayer_get_mediainfo(player_priv, &info);
if(ret < 0)
{
dt_info(TAG,"Get mediainfo failed, quit \n");
return -1;
}
dt_info(TAG,"Get Media Info Ok,filesize:%lld fulltime:%lld S \n",info.file_size,info.duration);
//set display win size
int width = 720;
int height = 480;
if(info.has_video)
{
vstream_info_t *vstream = info.vstreams[0];
width = vstream->width;
height = vstream->height;
}
if(width <= 0 || width > 1280)
width = 720;
if(height <= 0 || height >720)
height = 480;
dtplayer_set_video_size(player_priv, width, height);
ui_init(width,height);
render_init();
dtplayer_start (player_priv);
//event handle
player_event_t event = EVENT_NONE;
int arg = -1;
while(1)
{
if(ply_ctx.exit_flag == 1)
break;
event = get_event(&arg,&ply_ctx);
if(event == EVENT_NONE)
{
usleep(100);
continue;
}
switch(event)
{
case EVENT_PAUSE:
dtplayer_pause (player_priv);
break;
case EVENT_RESUME:
dtplayer_resume (player_priv);
break;
case EVENT_SEEK:
dtplayer_seekto (player_priv, arg);
break;
case EVENT_STOP:
dtplayer_stop (player_priv);
goto QUIT_CHECK;
break;
default:
dt_info(TAG,"UNKOWN CMD, IGNORE \n");
break;
}
}
QUIT_CHECK:
while(!ply_ctx.exit_flag)
{
usleep(100);
break;
}
render_stop();
ui_stop();
dt_info ("", "QUIT DTPLAYER-TEST\n");
return 0;
}
int main(int argc, char **argv)
#endif
#endif
{
int i;
#if HAVE_GSL
/* if HAVE_GSL and the environment variable GSL_IEEE_MODE exists, use it */
/* GSL_IEEE_MODE=double-precision,mask-underflow,mask-denormalized */
if (getenv("GSL_IEEE_MODE") != NULL)
gsl_ieee_env_setup();
gsl_set_error_handler(snd_gsl_error);
#endif
#if ENABLE_NLS && HAVE_GETTEXT && defined(LOCALE_DIR)
/* both flags needed to avoid idiotic confusion on the Sun */
#if HAVE_SETLOCALE
setlocale (LC_ALL, "");
#endif
bindtextdomain (PACKAGE, LOCALE_DIR);
textdomain (PACKAGE);
/*
(bindtextdomain "snd" "/usr/local/share/locale")
(textdomain "snd")
(define _ gettext)
(display (_ "no selection"))
but that is limited to Snd's messages
*/
#endif
ss = (snd_state *)CALLOC(1, sizeof(snd_state));
ss->fam_ok = false;
ss->startup_errors = NULL;
mus_sound_initialize(); /* has to precede version check (mus_audio_moniker needs to be setup in Alsa/Oss) */
#if HAVE_FORTH || HAVE_GAUCHE || HAVE_RUBY
xen_initialize();
#endif
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i], "--version") == 0)
{
fprintf(stdout, version_info());
snd_exit(0);
}
else
{
if (strcmp(argv[i], "--help") == 0)
{
fprintf(stdout, _("Snd is a sound editor; see http://ccrma.stanford.edu/software/snd/.\n"));
fprintf(stdout, version_info());
snd_exit(0);
}
}
}
initialize_format_lists();
snd_set_global_defaults(false);
#if MUS_DEBUGGING
ss->Trap_Segfault = false;
#else
ss->Trap_Segfault = DEFAULT_TRAP_SEGFAULT;
#endif
ss->jump_ok = false;
allocate_regions(max_regions(ss));
ss->init_window_x = DEFAULT_INIT_WINDOW_X;
ss->init_window_y = DEFAULT_INIT_WINDOW_Y;
ss->init_window_width = DEFAULT_INIT_WINDOW_WIDTH;
ss->init_window_height = DEFAULT_INIT_WINDOW_HEIGHT;
ss->click_time = 100;
init_sound_file_extensions();
ss->max_sounds = 4; /* expands to accommodate any number of files */
ss->sound_sync_max = 0;
ss->stopped_explicitly = false; /* C-g sets this flag so that we can interrupt various loops */
ss->checking_explicitly = false;
ss->reloading_updated_file = 0;
ss->selected_sound = NO_SELECTION;
ss->sounds = (snd_info **)CALLOC(ss->max_sounds, sizeof(snd_info *));
ss->print_choice = PRINT_SND;
ss->graph_hook_active = false;
ss->lisp_graph_hook_active = false;
ss->error_lock = false;
ss->exiting = false;
ss->deferred_regions = 0;
ss->fam_connection = NULL;
ss->snd_error_data = NULL;
ss->snd_error_handler = NULL;
ss->snd_warning_data = NULL;
ss->snd_warning_handler = NULL;
ss->xen_error_data = NULL;
ss->xen_error_handler = NULL;
#if USE_NO_GUI || HAVE_RUBY || HAVE_FORTH || HAVE_GAUCHE
ss->catch_exists = 1; /* scm_shell for USE_NO_GUI case */
#else
ss->catch_exists = 0;
#endif
#if HAVE_GL && MUS_WITH_GL2PS
ss->gl_printing = false;
#endif
g_xen_initialize();
ss->search_proc = XEN_UNDEFINED;
ss->search_expr = NULL;
ss->search_tree = NULL;
mus_error_set_handler(mus_error_to_snd);
mus_print_set_handler(mus_print_to_snd);
initialize_load_path(); /* merge SND_PATH entries into the load-path */
#ifdef SND_AS_PD_EXTERNAL
return;
#else
#ifdef SND_AS_WIDGET
return(ss);
#else
snd_doit(argc, argv);
#if (!HAVE_GUILE)
return(0);
#endif
#endif
#endif
}
