// parse a scheduler reply. // Some of the items go into the SCHEDULER_REPLY object. // Others are copied straight to the PROJECT // int SCHEDULER_REPLY::parse(FILE* in, PROJECT* project) { char buf[256], msg_buf[1024], pri_buf[256], attr_buf[256]; int retval; MIOFILE mf; XML_PARSER xp(&mf); std::string delete_file_name; mf.init_file(in); bool found_start_tag = false, btemp; double cpid_time = 0; clear(); safe_strcpy(host_venue, project->host_venue); // the project won't send us a venue if it's doing maintenance // or doesn't check the DB because no work. // Don't overwrite the host venue in that case. sr_feeds.clear(); trickle_up_urls.clear(); if (!project->anonymous_platform) { for (int i=0; i<MAX_RSC; i++) { project->no_rsc_apps[i] = false; } } // First line should either be tag (HTTP 1.0) or // hex length of response (HTTP 1.1) // while (!xp.get_tag(attr_buf, sizeof(attr_buf))) { if (!found_start_tag) { if (xp.match_tag("scheduler_reply")) { found_start_tag = true; } continue; } if (xp.match_tag("/scheduler_reply")) { // update statistics after parsing the scheduler reply // add new record if vector is empty or we have a new day // if (project->statistics.empty() || project->statistics.back().day!=dday()) { project->trim_statistics(); DAILY_STATS nds; project->statistics.push_back(nds); } DAILY_STATS& ds = project->statistics.back(); ds.day=dday(); ds.user_total_credit=project->user_total_credit; ds.user_expavg_credit=project->user_expavg_credit; ds.host_total_credit=project->host_total_credit; ds.host_expavg_credit=project->host_expavg_credit; project->write_statistics_file(); if (cpid_time) { project->cpid_time = cpid_time; } else { project->cpid_time = project->user_create_time; } if (project->dont_use_dcf) { project->duration_correction_factor = 1; } return 0; } else if (xp.parse_str("project_name", project->project_name, sizeof(project->project_name))) { continue; } else if (xp.parse_str("master_url", master_url, sizeof(master_url))) { continue; } else if (xp.parse_str("symstore", project->symstore, sizeof(project->symstore))) continue; else if (xp.parse_str("user_name", project->user_name, sizeof(project->user_name))) continue; else if (xp.parse_double("user_total_credit", project->user_total_credit)) continue; else if (xp.parse_double("user_expavg_credit", project->user_expavg_credit)) continue; else if (xp.parse_double("user_create_time", project->user_create_time)) continue; else if (xp.parse_double("cpid_time", cpid_time)) continue; else if (xp.parse_str("team_name", project->team_name, sizeof(project->team_name))) continue; else if (xp.parse_int("hostid", hostid)) continue; else if (xp.parse_double("host_total_credit", project->host_total_credit)) continue; else if (xp.parse_double("host_expavg_credit", project->host_expavg_credit)) continue; else if (xp.parse_str("host_venue", host_venue, sizeof(host_venue))) continue; else if (xp.parse_double("host_create_time", project->host_create_time)) continue; else if (xp.parse_double("request_delay", request_delay)) continue; else if (xp.parse_double("next_rpc_delay", next_rpc_delay)) continue; else if (xp.match_tag("global_preferences")) { retval = dup_element_contents( xp.f->f, "</global_preferences>", &global_prefs_xml ); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse global prefs in scheduler reply: %s", boincerror(retval) ); return retval; } } else if (xp.match_tag("project_preferences")) { retval = dup_element_contents( xp.f->f, "</project_preferences>", &project_prefs_xml ); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse project prefs in scheduler reply: %s", boincerror(retval) ); return retval; } } else if (xp.match_tag("gui_urls")) { std::string foo; retval = copy_element_contents(xp.f->f, "</gui_urls>", foo); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse GUI URLs in scheduler reply: %s", boincerror(retval) ); return retval; } project->gui_urls = "<gui_urls>\n"+foo+"</gui_urls>\n"; } else if (xp.match_tag("code_sign_key")) { retval = dup_element_contents( xp.f->f, "</code_sign_key>", &code_sign_key ); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse code sign key in scheduler reply: %s", boincerror(retval) ); return ERR_XML_PARSE; } strip_whitespace(code_sign_key); } else if (xp.match_tag("code_sign_key_signature")) { retval = dup_element_contents( xp.f->f, "</code_sign_key_signature>", &code_sign_key_signature ); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse code sign key signature in scheduler reply: %s", boincerror(retval) ); return ERR_XML_PARSE; } } else if (xp.match_tag("app")) { APP app; retval = app.parse(xp); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse application in scheduler reply: %s", boincerror(retval) ); } else { apps.push_back(app); } } else if (xp.match_tag("file_info")) { FILE_INFO file_info; retval = file_info.parse(xp); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse file info in scheduler reply: %s", boincerror(retval) ); } else { file_infos.push_back(file_info); } } else if (xp.match_tag("app_version")) { APP_VERSION av; retval = av.parse(xp); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse application version in scheduler reply: %s", boincerror(retval) ); } else { app_versions.push_back(av); } } else if (xp.match_tag("workunit")) { WORKUNIT wu; retval = wu.parse(xp); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse workunit in scheduler reply: %s", boincerror(retval) ); } else { workunits.push_back(wu); } } else if (xp.match_tag("result")) { RESULT result; // make sure this is here so constructor // gets called each time retval = result.parse_server(xp); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse task in scheduler reply: %s", boincerror(retval) ); } else { results.push_back(result); } } else if (xp.match_tag("result_ack")) { RESULT result; retval = result.parse_name(xp, "/result_ack"); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse ack in scheduler reply: %s", boincerror(retval) ); } else { result_acks.push_back(result); } } else if (xp.match_tag("result_abort")) { RESULT result; retval = result.parse_name(xp, "/result_abort"); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse result abort in scheduler reply: %s", boincerror(retval) ); } else { result_abort.push_back(result); } } else if (xp.match_tag("result_abort_if_not_started")) { RESULT result; retval = result.parse_name(xp, "/result_abort_if_not_started"); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't parse result abort-if-not-started in scheduler reply: %s", boincerror(retval) ); } else { result_abort_if_not_started.push_back(result); } } else if (xp.parse_string("delete_file_info", delete_file_name)) { file_deletes.push_back(delete_file_name); } else if (xp.parse_str("message", msg_buf, sizeof(msg_buf))) { parse_attr(attr_buf, "priority", pri_buf, sizeof(pri_buf)); USER_MESSAGE um(msg_buf, pri_buf); messages.push_back(um); continue; } else if (xp.parse_bool("message_ack", message_ack)) { continue; } else if (xp.parse_bool("project_is_down", project_is_down)) { continue; } else if (xp.parse_str("email_hash", project->email_hash, sizeof(project->email_hash))) { continue; } else if (xp.parse_str("cross_project_id", project->cross_project_id, sizeof(project->cross_project_id))) { continue; } else if (xp.parse_str("external_cpid", project->external_cpid, sizeof(project->external_cpid))) { continue; } else if (xp.match_tag("trickle_down")) { retval = gstate.handle_trickle_down(project, in); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "handle_trickle_down failed: %s", boincerror(retval) ); } continue; } else if (xp.parse_bool("non_cpu_intensive", project->non_cpu_intensive)) { continue; } else if (xp.parse_bool("ended", project->ended)) { continue; } else if (xp.parse_bool("no_cpu_apps", btemp)) { if (!project->anonymous_platform) { handle_no_rsc_apps("CPU", project, btemp); } continue; // deprecated syntax } else if (xp.parse_bool("no_cuda_apps", btemp)) { if (!project->anonymous_platform) { handle_no_rsc_apps(GPU_TYPE_NVIDIA, project, btemp); } continue; } else if (xp.parse_bool("no_ati_apps", btemp)) { if (!project->anonymous_platform) { handle_no_rsc_apps(GPU_TYPE_ATI, project, btemp); } continue; } else if (xp.parse_str("no_rsc_apps", buf, sizeof(buf))) { if (!project->anonymous_platform) { handle_no_rsc_apps(buf, project, true); } continue; } else if (xp.parse_bool("verify_files_on_app_start", project->verify_files_on_app_start)) { continue; } else if (xp.parse_bool("send_full_workload", send_full_workload)) { continue; } else if (xp.parse_bool("dont_use_dcf", dont_use_dcf)) { continue; } else if (xp.parse_int("send_time_stats_log", send_time_stats_log)){ continue; } else if (xp.parse_int("send_job_log", send_job_log)) { continue; } else if (xp.parse_int("scheduler_version", scheduler_version)) { continue; } else if (xp.match_tag("project_files")) { retval = parse_project_files(xp, project_files); #ifdef ENABLE_AUTO_UPDATE } else if (xp.match_tag("auto_update")) { retval = auto_update.parse(xp); if (!retval) auto_update.present = true; #endif } else if (xp.match_tag("rss_feeds")) { got_rss_feeds = true; parse_rss_feed_descs(xp, sr_feeds); continue; } else if (xp.match_tag("trickle_up_urls")) { parse_trickle_up_urls(xp, trickle_up_urls); continue; } else if (xp.parse_int("userid", project->userid)) { continue; } else if (xp.parse_int("teamid", project->teamid)) { continue; } else if (xp.parse_double("desired_disk_usage", project->desired_disk_usage)) { continue; } else { if (log_flags.unparsed_xml) { msg_printf(project, MSG_INFO, "[unparsed_xml] SCHEDULER_REPLY::parse(): unrecognized %s\n", xp.parsed_tag ); } } } if (found_start_tag) { msg_printf(project, MSG_INTERNAL_ERROR, "No close tag in scheduler reply"); } else { msg_printf(project, MSG_INTERNAL_ERROR, "No start tag in scheduler reply"); } return ERR_XML_PARSE; }
// Handle the reply from a scheduler // int CLIENT_STATE::handle_scheduler_reply( PROJECT* project, char* scheduler_url ) { SCHEDULER_REPLY sr; FILE* f; int retval; unsigned int i; bool signature_valid, update_global_prefs=false, update_project_prefs=false; char buf[1024], filename[256]; std::string old_gui_urls = project->gui_urls; PROJECT* p2; vector<RESULT*>new_results; project->last_rpc_time = now; if (requested_work()) { had_or_requested_work = true; } get_sched_reply_filename(*project, filename, sizeof(filename)); f = fopen(filename, "r"); if (!f) return ERR_FOPEN; retval = sr.parse(f, project); fclose(f); if (retval) return retval; if (log_flags.sched_ops) { if (requested_work()) { sprintf(buf, ": got %d new tasks", (int)sr.results.size()); } else { strcpy(buf, ""); } msg_printf(project, MSG_INFO, "Scheduler request completed%s", buf); } if (log_flags.sched_op_debug) { if (sr.scheduler_version) { msg_printf(project, MSG_INFO, "[sched_op] Server version %d", sr.scheduler_version ); } } // check that master URL is correct // if (strlen(sr.master_url)) { canonicalize_master_url(sr.master_url); string url1 = sr.master_url; string url2 = project->master_url; downcase_string(url1); downcase_string(url2); if (url1 != url2) { p2 = lookup_project(sr.master_url); if (p2) { msg_printf(project, MSG_USER_ALERT, "You are attached to this project twice. Please remove projects named %s, then add %s", project->project_name, sr.master_url ); } else { msg_printf(project, MSG_INFO, _("You used the wrong URL for this project. When convenient, remove this project, then add %s"), sr.master_url ); } } } // make sure we don't already have a project of same name // bool dup_name = false; for (i=0; i<projects.size(); i++) { p2 = projects[i]; if (project == p2) continue; if (!strcmp(p2->project_name, project->project_name)) { dup_name = true; break; } } if (dup_name) { msg_printf(project, MSG_INFO, "Already attached to a project named %s (possibly with wrong URL)", project->project_name ); msg_printf(project, MSG_INFO, "Consider detaching this project, then trying again" ); } // show messages from server // for (i=0; i<sr.messages.size(); i++) { USER_MESSAGE& um = sr.messages[i]; int prio = (!strcmp(um.priority.c_str(), "notice"))?MSG_SCHEDULER_ALERT:MSG_INFO; string_substitute(um.message.c_str(), buf, sizeof(buf), "%", "%%"); msg_printf(project, prio, "%s", buf); } if (log_flags.sched_op_debug && sr.request_delay) { msg_printf(project, MSG_INFO, "Project requested delay of %.0f seconds", sr.request_delay ); } // if project is down, return error (so that we back off) // and don't do anything else // if (sr.project_is_down) { if (sr.request_delay) { double x = now + sr.request_delay; project->set_min_rpc_time(x, "project is down"); } return ERR_PROJECT_DOWN; } // if the scheduler reply includes global preferences, // insert extra elements, write to disk, and parse // if (sr.global_prefs_xml) { // skip this if we have host-specific prefs // and we're talking to an old scheduler // if (!global_prefs.host_specific || sr.scheduler_version >= 507) { retval = save_global_prefs( sr.global_prefs_xml, project->master_url, scheduler_url ); if (retval) { return retval; } update_global_prefs = true; } else { if (log_flags.sched_op_debug) { msg_printf(project, MSG_INFO, "ignoring prefs from old server; we have host-specific prefs" ); } } } // see if we have a new venue from this project // (this must go AFTER the above, since otherwise // global_prefs_source_project() is meaningless) // if (strcmp(project->host_venue, sr.host_venue)) { safe_strcpy(project->host_venue, sr.host_venue); msg_printf(project, MSG_INFO, "New computer location: %s", sr.host_venue); update_project_prefs = true; if (project == global_prefs_source_project()) { strcpy(main_host_venue, sr.host_venue); update_global_prefs = true; } } if (update_global_prefs) { read_global_prefs(); } // deal with project preferences (should always be there) // If they've changed, write to account file, // then parse to get our venue, and pass to running apps // if (sr.project_prefs_xml) { if (strcmp(project->project_prefs.c_str(), sr.project_prefs_xml)) { project->project_prefs = string(sr.project_prefs_xml); update_project_prefs = true; } } // the account file has GUI URLs and project prefs. // rewrite if either of these has changed // if (project->gui_urls != old_gui_urls || update_project_prefs) { retval = project->write_account_file(); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't write account file: %s", boincerror(retval) ); return retval; } } if (update_project_prefs) { project->parse_account_file(); if (strlen(project->host_venue)) { project->parse_account_file_venue(); } project->parse_preferences_for_user_files(); active_tasks.request_reread_prefs(project); } // if the scheduler reply includes a code-signing key, // accept it if we don't already have one from the project. // Otherwise verify its signature, using the key we already have. // if (sr.code_sign_key) { if (!strlen(project->code_sign_key)) { safe_strcpy(project->code_sign_key, sr.code_sign_key); } else { if (sr.code_sign_key_signature) { retval = check_string_signature2( sr.code_sign_key, sr.code_sign_key_signature, project->code_sign_key, signature_valid ); if (!retval && signature_valid) { safe_strcpy(project->code_sign_key, sr.code_sign_key); } else { msg_printf(project, MSG_INTERNAL_ERROR, "New code signing key doesn't validate" ); } } else { msg_printf(project, MSG_INTERNAL_ERROR, "Missing code sign key signature" ); } } } // copy new entities to client state // for (i=0; i<sr.apps.size(); i++) { APP* app = lookup_app(project, sr.apps[i].name); if (app) { strcpy(app->user_friendly_name, sr.apps[i].user_friendly_name); } else { app = new APP; *app = sr.apps[i]; retval = link_app(project, app); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't handle application %s in scheduler reply", app->name ); delete app; } else { apps.push_back(app); } } } FILE_INFO* fip; for (i=0; i<sr.file_infos.size(); i++) { fip = lookup_file_info(project, sr.file_infos[i].name); if (fip) { fip->merge_info(sr.file_infos[i]); } else { fip = new FILE_INFO; *fip = sr.file_infos[i]; retval = link_file_info(project, fip); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't handle file %s in scheduler reply", fip->name ); delete fip; } else { file_infos.push_back(fip); } } } for (i=0; i<sr.file_deletes.size(); i++) { fip = lookup_file_info(project, sr.file_deletes[i].c_str()); if (fip) { if (log_flags.file_xfer_debug) { msg_printf(project, MSG_INFO, "[file_xfer_debug] Got server request to delete file %s", fip->name ); } fip->sticky = false; } } for (i=0; i<sr.app_versions.size(); i++) { if (project->anonymous_platform) { msg_printf(project, MSG_INTERNAL_ERROR, "App version returned from anonymous platform project; ignoring" ); continue; } APP_VERSION& avpp = sr.app_versions[i]; if (strlen(avpp.platform) == 0) { strcpy(avpp.platform, get_primary_platform()); } else { if (!is_supported_platform(avpp.platform)) { msg_printf(project, MSG_INTERNAL_ERROR, "App version has unsupported platform %s", avpp.platform ); continue; } } if (avpp.missing_coproc) { msg_printf(project, MSG_INTERNAL_ERROR, "App version uses non-existent %s GPU", avpp.missing_coproc_name ); } APP* app = lookup_app(project, avpp.app_name); if (!app) { msg_printf(project, MSG_INTERNAL_ERROR, "Missing app %s", avpp.app_name ); continue; } APP_VERSION* avp = lookup_app_version( app, avpp.platform, avpp.version_num, avpp.plan_class ); if (avp) { // update performance-related info; // generally this shouldn't change, // but if it does it's better to use the new stuff // avp->avg_ncpus = avpp.avg_ncpus; avp->max_ncpus = avpp.max_ncpus; avp->flops = avpp.flops; strcpy(avp->cmdline, avpp.cmdline); avp->gpu_usage = avpp.gpu_usage; strlcpy(avp->api_version, avpp.api_version, sizeof(avp->api_version)); avp->dont_throttle = avpp.dont_throttle; avp->needs_network = avpp.needs_network; // if we had download failures, clear them // avp->clear_errors(); continue; } avp = new APP_VERSION; *avp = avpp; retval = link_app_version(project, avp); if (retval) { delete avp; continue; } app_versions.push_back(avp); } for (i=0; i<sr.workunits.size(); i++) { if (lookup_workunit(project, sr.workunits[i].name)) continue; WORKUNIT* wup = new WORKUNIT; *wup = sr.workunits[i]; wup->project = project; retval = link_workunit(project, wup); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't handle task %s in scheduler reply", wup->name ); delete wup; continue; } wup->clear_errors(); workunits.push_back(wup); } double est_rsc_runtime[MAX_RSC]; for (int j=0; j<coprocs.n_rsc; j++) { est_rsc_runtime[j] = 0; } for (i=0; i<sr.results.size(); i++) { if (lookup_result(project, sr.results[i].name)) { msg_printf(project, MSG_INTERNAL_ERROR, "Already have task %s\n", sr.results[i].name ); continue; } RESULT* rp = new RESULT; *rp = sr.results[i]; retval = link_result(project, rp); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't handle task %s in scheduler reply", rp->name ); delete rp; continue; } if (strlen(rp->platform) == 0) { strcpy(rp->platform, get_primary_platform()); rp->version_num = latest_version(rp->wup->app, rp->platform); } rp->avp = lookup_app_version( rp->wup->app, rp->platform, rp->version_num, rp->plan_class ); if (!rp->avp) { msg_printf(project, MSG_INTERNAL_ERROR, "No app version found for app %s platform %s ver %d class %s; discarding %s", rp->wup->app->name, rp->platform, rp->version_num, rp->plan_class, rp->name ); delete rp; continue; } if (rp->avp->missing_coproc) { msg_printf(project, MSG_INTERNAL_ERROR, "Missing coprocessor for task %s; aborting", rp->name ); rp->abort_inactive(EXIT_MISSING_COPROC); } else { rp->set_state(RESULT_NEW, "handle_scheduler_reply"); int rt = rp->avp->gpu_usage.rsc_type; if (rt > 0) { est_rsc_runtime[rt] += rp->estimated_runtime(); gpus_usable = true; // trigger a check of whether GPU is actually usable } else { est_rsc_runtime[0] += rp->estimated_runtime(); } } rp->wup->version_num = rp->version_num; rp->received_time = now; new_results.push_back(rp); results.push_back(rp); } sort_results(); if (log_flags.sched_op_debug) { if (sr.results.size()) { for (int j=0; j<coprocs.n_rsc; j++) { msg_printf(project, MSG_INFO, "[sched_op] estimated total %s task duration: %.0f seconds", rsc_name(j), est_rsc_runtime[j]/time_stats.availability_frac(j) ); } } } // update records for ack'ed results // for (i=0; i<sr.result_acks.size(); i++) { if (log_flags.sched_op_debug) { msg_printf(project, MSG_INFO, "[sched_op] handle_scheduler_reply(): got ack for task %s\n", sr.result_acks[i].name ); } RESULT* rp = lookup_result(project, sr.result_acks[i].name); if (rp) { rp->got_server_ack = true; } else { msg_printf(project, MSG_INTERNAL_ERROR, "Got ack for task %s, but can't find it", sr.result_acks[i].name ); } } // handle result abort requests // for (i=0; i<sr.result_abort.size(); i++) { RESULT* rp = lookup_result(project, sr.result_abort[i].name); if (rp) { ACTIVE_TASK* atp = lookup_active_task_by_result(rp); if (atp) { atp->abort_task(EXIT_ABORTED_BY_PROJECT, "aborted by project - no longer usable" ); } else { rp->abort_inactive(EXIT_ABORTED_BY_PROJECT); } } else { msg_printf(project, MSG_INTERNAL_ERROR, "Server requested abort of unknown task %s", sr.result_abort[i].name ); } } for (i=0; i<sr.result_abort_if_not_started.size(); i++) { RESULT* rp = lookup_result(project, sr.result_abort_if_not_started[i].name); if (!rp) { msg_printf(project, MSG_INTERNAL_ERROR, "Server requested conditional abort of unknown task %s", sr.result_abort_if_not_started[i].name ); continue; } if (rp->not_started) { rp->abort_inactive(EXIT_ABORTED_BY_PROJECT); } } // remove acked trickle files // if (sr.message_ack) { remove_trickle_files(project); } if (sr.send_full_workload) { project->send_full_workload = true; } project->dont_use_dcf = sr.dont_use_dcf; project->send_time_stats_log = sr.send_time_stats_log; project->send_job_log = sr.send_job_log; project->trickle_up_pending = false; // The project returns a hostid only if it has created a new host record. // In that case reset RPC seqno // if (sr.hostid) { if (project->hostid) { // if we already have a host ID for this project, // we must have sent it a stale seqno, // which usually means our state file was copied from another host. // So generate a new host CPID. // generate_new_host_cpid(); msg_printf(project, MSG_INFO, "Generated new computer cross-project ID: %s", host_info.host_cpid ); } //msg_printf(project, MSG_INFO, "Changing host ID from %d to %d", project->hostid, sr.hostid); project->hostid = sr.hostid; project->rpc_seqno = 0; } #ifdef ENABLE_AUTO_UPDATE if (sr.auto_update.present) { if (!sr.auto_update.validate_and_link(project)) { auto_update = sr.auto_update; } } #endif project->project_files = sr.project_files; project->link_project_files(); project->create_project_file_symlinks(); if (log_flags.state_debug) { msg_printf(project, MSG_INFO, "[state] handle_scheduler_reply(): State after handle_scheduler_reply():" ); print_summary(); } // the following must precede the backoff and request_delay checks, // since it overrides them // if (sr.next_rpc_delay) { project->next_rpc_time = now + sr.next_rpc_delay; } else { project->next_rpc_time = 0; } work_fetch.handle_reply(project, &sr, new_results); project->nrpc_failures = 0; project->min_rpc_time = 0; if (sr.request_delay) { double x = now + sr.request_delay; project->set_min_rpc_time(x, "requested by project"); } if (sr.got_rss_feeds) { handle_sr_feeds(sr.sr_feeds, project); } update_trickle_up_urls(project, sr.trickle_up_urls); // garbage collect in case the project sent us some irrelevant FILE_INFOs; // avoid starting transfers for them // gstate.garbage_collect_always(); return 0; }
int CLIENT_STATE::parse_state_file_aux(const char* fname) { PROJECT *project=NULL; int retval=0; string stemp; FILE* f = fopen(fname, "r"); if (!f) return ERR_FOPEN; MIOFILE mf; XML_PARSER xp(&mf); mf.init_file(f); while (!xp.get_tag()) { if (xp.match_tag("/client_state")) { break; } if (xp.match_tag("client_state")) { continue; } if (xp.match_tag("project")) { PROJECT temp_project; retval = temp_project.parse_state(xp); if (retval) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't parse project in state file"); } else { #ifdef SIM project = new PROJECT; *project = temp_project; projects.push_back(project); #else project = lookup_project(temp_project.master_url); if (project) { project->copy_state_fields(temp_project); } else { msg_printf(&temp_project, MSG_INTERNAL_ERROR, "Project %s is in state file but no account file found", temp_project.get_project_name() ); } #endif } continue; } if (xp.match_tag("app")) { APP* app = new APP; retval = app->parse(xp); if (!project) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Application %s outside project in state file", app->name ); delete app; continue; } if (project->anonymous_platform) { delete app; continue; } if (retval) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't parse application in state file" ); delete app; continue; } retval = link_app(project, app); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't handle application %s in state file", app->name ); delete app; continue; } apps.push_back(app); continue; } if (xp.match_tag("file_info") || xp.match_tag("file")) { FILE_INFO* fip = new FILE_INFO; retval = fip->parse(xp); if (!project) { msg_printf(NULL, MSG_INTERNAL_ERROR, "File info outside project in state file" ); delete fip; continue; } if (retval) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't handle file info in state file" ); delete fip; continue; } retval = link_file_info(project, fip); if (project->anonymous_platform && retval == ERR_NOT_UNIQUE) { delete fip; continue; } if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't handle file info %s in state file", fip->name ); delete fip; continue; } file_infos.push_back(fip); #ifndef SIM // If the file had a failure before, // don't start another file transfer // int failnum; if (fip->had_failure(failnum)) { if (fip->pers_file_xfer) { delete fip->pers_file_xfer; fip->pers_file_xfer = NULL; } } if (fip->pers_file_xfer) { retval = fip->pers_file_xfer->init(fip, fip->pers_file_xfer->is_upload); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't initialize file transfer for %s", fip->name ); } retval = pers_file_xfers->insert(fip->pers_file_xfer); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't start persistent file transfer for %s", fip->name ); } } #endif continue; } if (xp.match_tag("app_version")) { APP_VERSION* avp = new APP_VERSION; retval = avp->parse(xp); if (!project) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Application version outside project in state file" ); delete avp; continue; } if (project->anonymous_platform) { delete avp; continue; } if (retval) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't parse application version in state file" ); delete avp; continue; } if (strlen(avp->platform) == 0) { safe_strcpy(avp->platform, get_primary_platform()); } else { if (!is_supported_platform(avp->platform)) { // if it's a platform we haven't heard of, // must be that the user tried out a 64 bit client // and then reverted to a 32-bit client. // Let's not throw away the app version and its WUs // #ifndef SIM msg_printf(project, MSG_INTERNAL_ERROR, "App version has unsupported platform %s; changing to %s", avp->platform, get_primary_platform() ); #endif safe_strcpy(avp->platform, get_primary_platform()); } } if (avp->missing_coproc) { msg_printf(project, MSG_INFO, "Application uses missing %s GPU", avp->missing_coproc_name ); } retval = link_app_version(project, avp); if (retval) { delete avp; continue; } app_versions.push_back(avp); continue; } if (xp.match_tag("workunit")) { WORKUNIT* wup = new WORKUNIT; retval = wup->parse(xp); if (!project) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Workunit outside project in state file" ); delete wup; continue; } if (retval) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't parse workunit in state file" ); delete wup; continue; } retval = link_workunit(project, wup); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't handle workunit in state file" ); delete wup; continue; } workunits.push_back(wup); continue; } if (xp.match_tag("result")) { RESULT* rp = new RESULT; retval = rp->parse_state(xp); if (!project) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Task %s outside project in state file", rp->name ); delete rp; continue; } if (retval) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't parse task in state file" ); delete rp; continue; } retval = link_result(project, rp); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't link task %s in state file", rp->name ); delete rp; continue; } // handle transition from old clients which didn't store result.platform; // skip for anon platform if (!project->anonymous_platform) { if (!strlen(rp->platform) || !is_supported_platform(rp->platform)) { safe_strcpy(rp->platform, get_primary_platform()); rp->version_num = latest_version(rp->wup->app, rp->platform); } } rp->avp = lookup_app_version( rp->wup->app, rp->platform, rp->version_num, rp->plan_class ); if (!rp->avp) { msg_printf(project, MSG_INTERNAL_ERROR, "No application found for task: %s %d %s; discarding", rp->platform, rp->version_num, rp->plan_class ); delete rp; continue; } if (rp->avp->missing_coproc) { msg_printf(project, MSG_INFO, "Missing coprocessor for task %s", rp->name ); rp->coproc_missing = true; } rp->wup->version_num = rp->version_num; results.push_back(rp); continue; } if (xp.match_tag("project_files")) { if (!project) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Project files outside project in state file" ); xp.skip_unexpected(); continue; } parse_project_files(xp, project->project_files); project->link_project_files(); continue; } if (xp.match_tag("host_info")) { #ifdef SIM retval = host_info.parse(xp, false); coprocs = host_info.coprocs; coprocs.bound_counts(); #else retval = host_info.parse(xp, true); #endif if (retval) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't parse host info in state file" ); } continue; } if (xp.match_tag("time_stats")) { retval = time_stats.parse(xp); if (retval) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't parse time stats in state file" ); } continue; } if (xp.match_tag("net_stats")) { retval = net_stats.parse(xp); if (retval) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't parse network stats in state file" ); } continue; } if (xp.match_tag("active_task_set")) { retval = active_tasks.parse(xp); if (retval) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't parse active tasks in state file" ); } continue; } if (xp.parse_string("platform_name", statefile_platform_name)) { continue; } if (xp.parse_string("alt_platform", stemp)) { continue; } if (xp.parse_int("user_run_request", retval)) { cpu_run_mode.set(retval, 0); continue; } if (xp.parse_int("user_run_prev_request", retval)) { cpu_run_mode.set_prev(retval); continue; } if (xp.parse_int("user_gpu_request", retval)) { gpu_run_mode.set(retval, 0); continue; } if (xp.parse_int("user_gpu_prev_request", retval)) { gpu_run_mode.set_prev(retval); continue; } if (xp.parse_int("user_network_request", retval)) { network_run_mode.set(retval, 0); continue; } if (xp.parse_int("core_client_major_version", old_major_version)) { continue; } if (xp.parse_int("core_client_minor_version", old_minor_version)) { continue; } if (xp.parse_int("core_client_release", old_release)) { continue; } if (xp.parse_str("language", language, sizeof(language))) { continue; } if (xp.match_tag("proxy_info")) { retval = gui_proxy_info.parse(xp); if (retval) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't parse proxy info in state file" ); } continue; } if (xp.parse_str("host_venue", main_host_venue, sizeof(main_host_venue))) { continue; } if (xp.parse_double("new_version_check_time", new_version_check_time)) { continue; } if (xp.parse_double("all_projects_list_check_time", all_projects_list_check_time)) { continue; } if (xp.parse_string("newer_version", newer_version)) { continue; } #ifdef ENABLE_AUTO_UPDATE if (xp.match_tag("auto_update")) { if (!project) { msg_printf(NULL, MSG_INTERNAL_ERROR, "auto update outside project in state file" ); xp.skip_unexpected(); continue; } if (!auto_update.parse(xp) && !auto_update.validate_and_link(project)) { auto_update.present = true; } continue; } #endif if (log_flags.unparsed_xml) { msg_printf(0, MSG_INFO, "[unparsed_xml] state_file: unrecognized: %s", xp.parsed_tag ); } xp.skip_unexpected(); } sort_results(); fclose(f); // if total resource share is zero, set all shares to 1 // if (projects.size()) { unsigned int i; double x=0; for (i=0; i<projects.size(); i++) { x += projects[i]->resource_share; } if (!x) { msg_printf(NULL, MSG_INFO, "All projects have zero resource share; setting to 100" ); for (i=0; i<projects.size(); i++) { projects[i]->resource_share = 100; } } } return 0; }