static void handle_get_cc_status(GUI_RPC_CONN* gr, MIOFILE& fout) { fout.printf( "<cc_status>\n" " <network_status>%d</network_status>\n" " <ams_password_error>%d</ams_password_error>\n" " <task_suspend_reason>%d</task_suspend_reason>\n" " <task_mode>%d</task_mode>\n" " <task_mode_perm>%d</task_mode_perm>\n" " <task_mode_delay>%f</task_mode_delay>\n" " <gpu_suspend_reason>%d</gpu_suspend_reason>\n" " <gpu_mode>%d</gpu_mode>\n" " <gpu_mode_perm>%d</gpu_mode_perm>\n" " <gpu_mode_delay>%f</gpu_mode_delay>\n" " <network_suspend_reason>%d</network_suspend_reason>\n" " <network_mode>%d</network_mode>\n" " <network_mode_perm>%d</network_mode_perm>\n" " <network_mode_delay>%f</network_mode_delay>\n" " <disallow_attach>%d</disallow_attach>\n" " <simple_gui_only>%ds</simple_gui_only>\n", net_status.network_status(), gstate.acct_mgr_info.password_error?1:0, gstate.suspend_reason, gstate.run_mode.get_current(), gstate.run_mode.get_perm(), gstate.run_mode.delay(), gpu_suspend_reason, gstate.gpu_mode.get_current(), gstate.gpu_mode.get_perm(), gstate.gpu_mode.delay(), gstate.network_suspend_reason, gstate.network_mode.get_current(), gstate.network_mode.get_perm(), gstate.network_mode.delay(), config.disallow_attach?1:0, config.simple_gui_only?1:0 ); if (gr->au_mgr_state == AU_MGR_QUIT_REQ) { fout.printf( " <manager_must_quit>1</manager_must_quit>\n" ); gr->au_mgr_state = AU_MGR_QUIT_SENT; } fout.printf( "</cc_status>\n" ); }
static void handle_get_screensaver_tasks(MIOFILE& fout) { unsigned int i; ACTIVE_TASK* atp; fout.printf( "<handle_get_screensaver_tasks>\n" " <suspend_reason>%d</suspend_reason>\n", gstate.suspend_reason ); for (i=0; i<gstate.active_tasks.active_tasks.size(); i++) { atp = gstate.active_tasks.active_tasks[i]; if ((atp->task_state() == PROCESS_EXECUTING) || ((atp->task_state() == PROCESS_SUSPENDED) && (gstate.suspend_reason == SUSPEND_REASON_CPU_THROTTLE))) { atp->result->write_gui(fout); } } fout.printf("</handle_get_screensaver_tasks>\n"); }
// Write time statistics // to_remote means GUI RPC reply; else writing client state file // int CLIENT_TIME_STATS::write(MIOFILE& out, bool to_remote) { out.printf( "<time_stats>\n" " <on_frac>%f</on_frac>\n" " <connected_frac>%f</connected_frac>\n" " <cpu_and_network_available_frac>%f</cpu_and_network_available_frac>\n" " <active_frac>%f</active_frac>\n" " <gpu_active_frac>%f</gpu_active_frac>\n" " <client_start_time>%f</client_start_time>\n" " <total_start_time>%f</total_start_time>\n" " <total_duration>%f</total_duration>\n" " <total_active_duration>%f</total_active_duration>\n" " <total_gpu_active_duration>%f</total_gpu_active_duration>\n", on_frac, connected_frac, cpu_and_network_available_frac, active_frac, gpu_active_frac, client_start_time, total_start_time, total_duration, total_active_duration, total_gpu_active_duration ); if (to_remote) { out.printf( " <now>%f</now>\n" " <previous_uptime>%f</previous_uptime>\n" " <session_active_duration>%f</session_active_duration>\n" " <session_gpu_active_duration>%f</session_gpu_active_duration>\n", gstate.now, previous_uptime, session_active_duration, session_gpu_active_duration ); } else { out.printf( " <previous_uptime>%f</previous_uptime>\n" " <last_update>%f</last_update>\n", gstate.now - client_start_time, last_update ); } out.printf("</time_stats>\n"); return 0; }
static void read_all_projects_list_file(MIOFILE& fout) { string s; int retval = read_file_string(ALL_PROJECTS_LIST_FILENAME, s); if (!retval) { strip_whitespace(s); fout.printf("%s\n", s.c_str()); } }
static void handle_get_cc_config(MIOFILE& fout) { string s; int retval = read_file_string(CONFIG_FILE, s); if (!retval) { strip_whitespace(s); fout.printf("%s\n", s.c_str()); } }
static void handle_get_newer_version(MIOFILE& fout) { fout.printf( "<newer_version>%s</newer_version>\n" "<download_url>%s</download_url>\n", gstate.newer_version.c_str(), config.client_download_url.c_str() ); }
void GUI_RPC_CONN::handle_create_account(char* buf, MIOFILE& fout) { ACCOUNT_IN ai; ai.parse(buf); create_account_op.do_rpc(ai); fout.printf("<success/>\n"); }
// write XML list of supported platforms // void CLIENT_STATE::write_platforms(PROJECT* p, MIOFILE& mf) { mf.printf( " <platform_name>%s</platform_name>\n", p->anonymous_platform ? "anonymous" : get_primary_platform() ); for (unsigned int i=1; i<platforms.size(); i++) { PLATFORM& platform = platforms[i]; mf.printf( " <alt_platform>\n" " <name>%s</name>\n" " </alt_platform>\n", platform.name.c_str() ); } }
void COPROC::write_xml(MIOFILE& f, bool scheduler_rpc) { f.printf( "<coproc>\n" " <type>%s</type>\n" " <count>%d</count>\n", type, count ); if (scheduler_rpc) { write_request(f); } if (have_opencl) { opencl_prop.write_xml(f, "coproc_opencl"); } f.printf("</coproc>\n"); }
void GUI_RPC_CONN::handle_get_project_config(char* buf, MIOFILE& fout) { string url; parse_str(buf, "<url>", url); canonicalize_master_url(url); get_project_config_op.do_rpc(url); fout.printf("<success/>\n"); }
void COPROC::write_xml(MIOFILE& f) { f.printf( "<coproc>\n" " <type>%s</type>\n" " <count>%d</count>\n" "</coproc>\n", type, count ); }
static void handle_acct_mgr_rpc_poll(char*, MIOFILE& fout) { fout.printf( "<acct_mgr_rpc_reply>\n" ); if (gstate.acct_mgr_op.error_str.size()) { fout.printf( " <message>%s</message>\n", gstate.acct_mgr_op.error_str.c_str() ); } fout.printf( " <error_num>%d</error_num>\n", gstate.acct_mgr_op.error_num ); fout.printf( "</acct_mgr_rpc_reply>\n" ); }
int COPROCS::write_coproc_info_file(vector<string> &warnings) { MIOFILE mf; unsigned int i, temp; FILE* f; f = boinc_fopen(COPROC_INFO_FILENAME, "wb"); if (!f) return ERR_FOPEN; mf.init_file(f); mf.printf(" <coprocs>\n"); for (i=0; i<ati_gpus.size(); ++i) { ati_gpus[i].write_xml(mf, false); } for (i=0; i<nvidia_gpus.size(); ++i) { temp = nvidia_gpus[i].count; nvidia_gpus[i].count = 1; nvidia_gpus[i].pci_infos[0] = nvidia_gpus[i].pci_info; nvidia_gpus[i].write_xml(mf, false); nvidia_gpus[i].count = temp; } for (i=0; i<intel_gpus.size(); ++i) { intel_gpus[i].write_xml(mf, false); } for (i=0; i<ati_opencls.size(); ++i) { ati_opencls[i].write_xml(mf, "ati_opencl", true); } for (i=0; i<nvidia_opencls.size(); ++i) { nvidia_opencls[i].write_xml(mf, "nvidia_opencl", true); } for (i=0; i<intel_gpu_opencls.size(); ++i) { intel_gpu_opencls[i].write_xml(mf, "intel_gpu_opencl", true); } for (i=0; i<cpu_opencls.size(); i++) { cpu_opencls[i].write_xml(mf); } for (i=0; i<warnings.size(); ++i) { mf.printf("<warning>%s</warning>\n", warnings[i].c_str()); } mf.printf(" </coprocs>\n"); fclose(f); return 0; }
int CERT_SIGS::write(MIOFILE &f) { if (this->signatures.size()==0) return true; f.printf("<signatures>\n"); for(unsigned int i=0;i < this->signatures.size(); i++) { f.printf(" <entry>\n"); f.printf(" <signature>\n%s\n", this->signatures.at(i).signature); f.printf(" </signature>\n"); f.printf(" <subject>%s</subject>\n", this->signatures.at(i).subject); f.printf(" <type>%s</type>\n", (this->signatures.at(i).type == MD5_HASH) ? "md5" : "sha1"); f.printf(" <hash>%s</hash>\n", this->signatures.at(i).hash); f.printf(" </entry>\n"); } f.printf("</signatures>\n"); return true; }
static void handle_result_show_graphics(char* buf, MIOFILE& fout) { string result_name; GRAPHICS_MSG gm; ACTIVE_TASK* atp; if (match_tag(buf, "<full_screen/>")) { gm.mode = MODE_FULLSCREEN; } else if (match_tag(buf, "<hide/>")) { gm.mode = MODE_HIDE_GRAPHICS; } else { gm.mode = MODE_WINDOW; } parse_str(buf, "<window_station>", gm.window_station, sizeof(gm.window_station)); parse_str(buf, "<desktop>", gm.desktop, sizeof(gm.desktop)); parse_str(buf, "<display>", gm.display, sizeof(gm.display)); if (parse_str(buf, "<result_name>", result_name)) { PROJECT* p = get_project(buf, fout); if (!p) { fout.printf("<error>No such project</error>\n"); return; } RESULT* rp = gstate.lookup_result(p, result_name.c_str()); if (!rp) { fout.printf("<error>No such result</error>\n"); return; } atp = gstate.lookup_active_task_by_result(rp); if (!atp) { fout.printf("<error>no such result</error>\n"); return; } atp->request_graphics_mode(gm); } else { for (unsigned int i=0; i<gstate.active_tasks.active_tasks.size(); i++) { atp = gstate.active_tasks.active_tasks[i]; if (atp->scheduler_state != CPU_SCHED_SCHEDULED) continue; atp->request_graphics_mode(gm); } } fout.printf("<success/>\n"); }
static void handle_project_attach_poll(char*, MIOFILE& fout) { unsigned int i; fout.printf( "<project_attach_reply>\n" ); for (i=0; i<gstate.project_attach.messages.size(); i++) { fout.printf( " <message>%s</message>\n", gstate.project_attach.messages[i].c_str() ); } fout.printf( " <error_num>%d</error_num>\n", gstate.project_attach.error_num ); fout.printf( "</project_attach_reply>\n" ); }
static void handle_set_run_mode(char* buf, MIOFILE& fout) { double duration = 0; int mode; parse_double(buf, "<duration>", duration); if (match_tag(buf, "<always")) { mode = RUN_MODE_ALWAYS; } else if (match_tag(buf, "<never")) { mode = RUN_MODE_NEVER; } else if (match_tag(buf, "<auto")) { mode = RUN_MODE_AUTO; } else if (match_tag(buf, "<restore")) { mode = RUN_MODE_RESTORE; } else { fout.printf("<error>Missing mode</error>\n"); return; } gstate.run_mode.set(mode, duration); fout.printf("<success/>\n"); }
void COPROC::write_request(MIOFILE& f) { f.printf( " <req_secs>%f</req_secs>\n" " <req_instances>%f</req_instances>\n" " <estimated_delay>%f</estimated_delay>\n", req_secs, req_instances, estimated_delay ); }
static void handle_result_op(char* buf, MIOFILE& fout, const char* op) { RESULT* rp; char result_name[256]; ACTIVE_TASK* atp; PROJECT* p = get_project(buf, fout); if (!p) { fout.printf("<error>No such project</error>\n"); return; } if (!parse_str(buf, "<name>", result_name, sizeof(result_name))) { fout.printf("<error>Missing result name</error>\n"); return; } rp = gstate.lookup_result(p, result_name); if (!rp) { fout.printf("<error>no such result</error>\n"); return; } if (!strcmp(op, "abort")) { msg_printf(p, MSG_INFO, "task %s aborted by user", result_name); atp = gstate.lookup_active_task_by_result(rp); if (atp) { atp->abort_task(ERR_ABORTED_VIA_GUI, "aborted by user"); } else { rp->abort_inactive(ERR_ABORTED_VIA_GUI); } gstate.request_work_fetch("result aborted by user"); } else if (!strcmp(op, "suspend")) { msg_printf(p, MSG_INFO, "task %s suspended by user", result_name); rp->suspended_via_gui = true; gstate.request_work_fetch("result suspended by user"); } else if (!strcmp(op, "resume")) { msg_printf(p, MSG_INFO, "task %s resumed by user", result_name); rp->suspended_via_gui = false; } gstate.request_schedule_cpus("result suspended, resumed or aborted by user"); gstate.set_client_state_dirty("Result RPC"); fout.printf("<success/>\n"); }
void MESSAGE_DESCS::write(int seqno, MIOFILE& fout, bool translatable) { int i, j; unsigned int k; MESSAGE_DESC* mdp; char buf[1024]; // messages are stored in descreasing seqno, // i.e. newer ones are at the head of the vector. // compute j = index of first message to return // j = (int)msgs.size()-1; for (k=0; k<msgs.size(); k++) { mdp = msgs[k]; if (mdp->seqno <= seqno) { j = k-1; break; } } fout.printf("<msgs>\n"); for (i=j; i>=0; i--) { mdp = msgs[i]; strcpy(buf, mdp->message.c_str()); if (!translatable) { strip_translation(buf); } fout.printf( "<msg>\n" " <project>%s</project>\n" " <pri>%d</pri>\n" " <seqno>%d</seqno>\n" " <body>\n%s\n</body>\n" " <time>%d</time>\n", mdp->project_name, mdp->priority, mdp->seqno, buf, mdp->timestamp ); fout.printf("</msg>\n"); } fout.printf("</msgs>\n"); }
/* * request: receive battery info */ static void handle_battery_info(char* buf, bool is_local, MIOFILE& fout) { if (is_local) { MIOFILE in; in.init_buf_read(buf); if (gstate.battery_info.parse(in)!=0) return; /*msg_printf(0, MSG_INFO, "Battery info reveived: %s,%s,%f,%f\n", gstate.battery_info.present?"1":"0", gstate.battery_info.plugged?"1":"0", gstate.battery_info.level, gstate.battery_info.temperature);*/ gstate.battery_info_initialized = true; fout.printf("<success/>\n"); } else { // no access if not local fout.printf("<failed/>\n"); return; } }
// <active_task_state> is here for the benefit of 3rd-party software // that reads the client state file // int ACTIVE_TASK::write(MIOFILE& fout) { fout.printf( "<active_task>\n" " <project_master_url>%s</project_master_url>\n" " <result_name>%s</result_name>\n" " <active_task_state>%d</active_task_state>\n" " <app_version_num>%d</app_version_num>\n" " <slot>%d</slot>\n" " <checkpoint_cpu_time>%f</checkpoint_cpu_time>\n" " <checkpoint_elapsed_time>%f</checkpoint_elapsed_time>\n" " <checkpoint_fraction_done>%f</checkpoint_fraction_done>\n" " <checkpoint_fraction_done_elapsed_time>%f</checkpoint_fraction_done_elapsed_time>\n" " <current_cpu_time>%f</current_cpu_time>\n" " <once_ran_edf>%d</once_ran_edf>\n" " <swap_size>%f</swap_size>\n" " <working_set_size>%f</working_set_size>\n" " <working_set_size_smoothed>%f</working_set_size_smoothed>\n" " <page_fault_rate>%f</page_fault_rate>\n" " <bytes_sent>%f</bytes_sent>\n" " <bytes_received>%f</bytes_received>\n", result->project->master_url, result->name, task_state(), app_version->version_num, slot, checkpoint_cpu_time, checkpoint_elapsed_time, checkpoint_fraction_done, checkpoint_fraction_done_elapsed_time, current_cpu_time, once_ran_edf?1:0, procinfo.swap_size, procinfo.working_set_size, procinfo.working_set_size_smoothed, procinfo.page_fault_rate, bytes_sent, bytes_received ); fout.printf("</active_task>\n"); return 0; }
static void handle_get_global_prefs_file(MIOFILE& fout) { GLOBAL_PREFS p; bool found; int retval = p.parse_file( GLOBAL_PREFS_FILE_NAME, gstate.main_host_venue, found ); if (retval) { fout.printf("<error>%d</error>\n", retval); return; } p.write(fout); }
int APP::write(MIOFILE& out) { out.printf( "<app>\n" " <name>%s</name>\n" " <user_friendly_name>%s</user_friendly_name>\n" " <non_cpu_intensive>%d</non_cpu_intensive>\n" "</app>\n", name, user_friendly_name, non_cpu_intensive?1:0 ); return 0; }
void DAILY_XFER_HISTORY::write_scheduler_request(MIOFILE& mf, int ndays) { double up, down; totals(ndays, up, down); mf.printf( "<daily_xfer_history>\n" " <ndays>%d</ndays>\n" " <up>%f</up>\n" " <down>%f</down>\n" "</daily_xfer_history>\n", ndays, up, down ); }
void PCI_INFO::write(MIOFILE& f) { f.printf( "<pci_info>\n" " <bus_id>%d</bus_id>\n" " <device_id>%d</device_id>\n" " <domain_id>%d</domain_id>\n" "</pci_info>\n", bus_id, device_id, domain_id ); }
// client passes its version, but ignore it for now // static void handle_exchange_versions(MIOFILE& fout) { fout.printf( "<server_version>\n" " <major>%d</major>\n" " <minor>%d</minor>\n" " <release>%d</release>\n" "</server_version>\n", BOINC_MAJOR_VERSION, BOINC_MINOR_VERSION, BOINC_RELEASE ); }
static void handle_set_proxy_settings(char* buf, MIOFILE& fout) { MIOFILE in; in.init_buf_read(buf); gui_proxy_info.parse(in); gstate.set_client_state_dirty("Set proxy settings RPC"); fout.printf("<success/>\n"); select_proxy_info(); // tell running apps to reread app_info file (for F@h) // gstate.active_tasks.request_reread_app_info(); }
static void handle_update_projects_apps_poll(char* buf, bool is_local, MIOFILE& fout) { if (!is_local) { fout.printf("<update_project_apps_reply>\n" " <error_num>%d</error_num>\n</update_project_apps_reply>\n", ERR_UNAUTH); return; } string url; if (!parse_str(buf, "<project_url>", url)) { fout.printf("<update_project_apps_reply>\n" " <error_num>%d</error_num>\n</update_project_apps_reply>\n", ERR_UPDATE_APPS); return; } for (unsigned int i=0;i<gstate.projects.size();i++) { PROJECT* project = gstate.projects[i]; if (!strcmp(project->master_url,url.c_str())) { if (!project->suspended_during_update) { if (project->pending_to_exit==0) { // ok fout.printf("<update_project_apps_reply>\n" " <message>OK</message>\n</update_project_apps_reply>\n"); project->pending_to_exit = -1; project->dont_preempt_suspended = false; return; } } else { // if retry fout.printf("<update_project_apps_reply>\n" " <error_num>%d</error_num>\n</update_project_apps_reply>\n", ERR_IN_PROGRESS); return; } } } // failed fout.printf("<update_project_apps_reply>\n" " <error_num>%d</error_num>\n</update_project_apps_reply>\n", ERR_UPDATE_APPS); }
// params: // [ <seqno>n</seqno> ] // return only msgs with seqno > n; if absent or zero, return all // static void handle_get_messages(char* buf, MIOFILE& fout) { int seqno=0, i, j; unsigned int k; MESSAGE_DESC* mdp; parse_int(buf, "<seqno>", seqno); // messages are stored in descreasing seqno, // i.e. newer ones are at the head of the vector. // compute j = index of first message to return // j = (int)message_descs.size()-1; for (k=0; k<message_descs.size(); k++) { mdp = message_descs[k]; if (mdp->seqno <= seqno) { j = k-1; break; } } fout.printf("<msgs>\n"); for (i=j; i>=0; i--) { mdp = message_descs[i]; fout.printf( "<msg>\n" " <project>%s</project>\n" " <pri>%d</pri>\n" " <seqno>%d</seqno>\n" " <body>\n%s\n</body>\n" " <time>%d</time>\n", mdp->project_name, mdp->priority, mdp->seqno, mdp->message.c_str(), mdp->timestamp ); fout.printf("</msg>\n"); } fout.printf("</msgs>\n"); }