2005-01-20 23:22:22 +00:00
|
|
|
// Berkeley Open Infrastructure for Network Computing
|
|
|
|
// http://boinc.berkeley.edu
|
|
|
|
// Copyright (C) 2005 University of California
|
2003-07-25 20:26:38 +00:00
|
|
|
//
|
2005-01-20 23:22:22 +00:00
|
|
|
// This is free software; you can redistribute it and/or
|
|
|
|
// modify it under the terms of the GNU Lesser General Public
|
|
|
|
// License as published by the Free Software Foundation;
|
|
|
|
// either version 2.1 of the License, or (at your option) any later version.
|
2003-07-25 20:26:38 +00:00
|
|
|
//
|
2005-01-20 23:22:22 +00:00
|
|
|
// This software is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
// See the GNU Lesser General Public License for more details.
|
2002-04-30 22:22:54 +00:00
|
|
|
//
|
2005-01-20 23:22:22 +00:00
|
|
|
// To view the GNU Lesser General Public License visit
|
|
|
|
// http://www.gnu.org/copyleft/lesser.html
|
|
|
|
// or write to the Free Software Foundation, Inc.,
|
|
|
|
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2003-05-02 23:29:57 +00:00
|
|
|
#ifndef _BOINC_DB_
|
|
|
|
#define _BOINC_DB_
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2002-09-26 05:57:10 +00:00
|
|
|
// Structures corresponding to database records.
|
|
|
|
// Some of these types have counterparts in client/types.h,
|
|
|
|
// but don't be deceived - client and server have different variants.
|
2002-04-30 22:22:54 +00:00
|
|
|
|
|
|
|
// The parse and write functions are for use in scheduler RPC.
|
|
|
|
// They don't necessarily serialize the entire records.
|
|
|
|
|
2004-07-13 13:54:09 +00:00
|
|
|
#include <cstdio>
|
2004-07-01 20:24:00 +00:00
|
|
|
#include <vector>
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2003-08-31 01:21:31 +00:00
|
|
|
#include "db_base.h"
|
|
|
|
|
2003-09-05 21:26:21 +00:00
|
|
|
extern DB_CONN boinc_db;
|
|
|
|
|
2003-12-07 18:58:08 +00:00
|
|
|
// Sizes of text buffers in memory, corresponding to database BLOBs.
|
|
|
|
// Large is for fields with user-supplied text, and preferences
|
|
|
|
|
|
|
|
#define LARGE_BLOB_SIZE 65536
|
2006-01-24 21:38:03 +00:00
|
|
|
#define MSG_FROM_HOST_BLOB_SIZE 262144
|
|
|
|
#define MSG_TO_HOST_BLOB_SIZE 262144
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2004-08-06 20:02:00 +00:00
|
|
|
// Dummy name for file xfers
|
|
|
|
#define FILE_MOVER "move_file"
|
|
|
|
|
2002-08-25 07:54:33 +00:00
|
|
|
|
2002-04-30 22:22:54 +00:00
|
|
|
// A compilation target, i.e. a architecture/OS combination.
|
2002-12-18 01:34:51 +00:00
|
|
|
// The core client will be given only applications with the same platform
|
2002-04-30 22:22:54 +00:00
|
|
|
//
|
|
|
|
struct PLATFORM {
|
|
|
|
int id;
|
2003-08-15 20:35:44 +00:00
|
|
|
int create_time;
|
2003-06-04 17:21:26 +00:00
|
|
|
char name[256]; // i.e. "sparc-sun-solaris"
|
|
|
|
char user_friendly_name[256]; // i.e. "SPARC Solaris 2.8"
|
2003-12-11 19:05:52 +00:00
|
|
|
int deprecated;
|
2003-06-04 17:21:26 +00:00
|
|
|
void clear();
|
2002-04-30 22:22:54 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// An application.
|
|
|
|
//
|
|
|
|
struct APP {
|
|
|
|
int id;
|
2003-08-15 20:35:44 +00:00
|
|
|
int create_time;
|
2003-06-05 18:16:37 +00:00
|
|
|
char name[256]; // application name, preferably short
|
|
|
|
int min_version; // don't use app versions before this
|
2004-09-27 04:26:51 +00:00
|
|
|
bool deprecated;
|
2003-12-11 19:05:52 +00:00
|
|
|
char user_friendly_name[256];
|
2004-09-27 04:26:51 +00:00
|
|
|
bool homogeneous_redundancy;
|
2006-07-11 21:49:20 +00:00
|
|
|
double weight; // tells the feeder what fraction of results
|
|
|
|
// should come from this app
|
2006-10-22 01:46:33 +00:00
|
|
|
bool beta;
|
2004-09-27 04:26:51 +00:00
|
|
|
|
2002-04-30 22:22:54 +00:00
|
|
|
int write(FILE*);
|
2003-06-04 17:21:26 +00:00
|
|
|
void clear();
|
2002-04-30 22:22:54 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// A version of an application.
|
|
|
|
//
|
|
|
|
struct APP_VERSION {
|
|
|
|
int id;
|
2003-08-15 20:35:44 +00:00
|
|
|
int create_time;
|
2002-08-26 22:57:17 +00:00
|
|
|
int appid;
|
|
|
|
int version_num;
|
|
|
|
int platformid;
|
2004-05-13 18:18:22 +00:00
|
|
|
char xml_doc[LARGE_BLOB_SIZE];
|
2003-07-01 18:27:08 +00:00
|
|
|
// describes app files. format:
|
|
|
|
// <file_info>...</file_info>
|
|
|
|
// ...
|
2003-06-04 17:21:26 +00:00
|
|
|
// <app_version>
|
|
|
|
// <app_name>...</app_name>
|
|
|
|
// <version_num>x</version_num>
|
2003-07-01 18:27:08 +00:00
|
|
|
// <file_ref>
|
|
|
|
// ...
|
2003-06-04 17:21:26 +00:00
|
|
|
// [<main_program/>]
|
2003-07-01 18:27:08 +00:00
|
|
|
// [<copy_file/>]
|
|
|
|
// </file_ref>
|
2003-06-04 17:21:26 +00:00
|
|
|
// </app_version>
|
2003-07-01 18:27:08 +00:00
|
|
|
//
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2003-06-04 17:21:26 +00:00
|
|
|
// the following let you handle backwards-incompatible changes to
|
2002-04-30 22:22:54 +00:00
|
|
|
// the core client / app interface
|
|
|
|
//
|
2003-06-05 18:16:37 +00:00
|
|
|
int min_core_version; // min core version this app will run with
|
2002-04-30 22:22:54 +00:00
|
|
|
int max_core_version; // if <>0, max core version this will run with
|
2003-12-24 21:49:35 +00:00
|
|
|
bool deprecated;
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2005-02-16 23:17:43 +00:00
|
|
|
int write(FILE*);
|
2003-06-04 17:21:26 +00:00
|
|
|
void clear();
|
2002-04-30 22:22:54 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct USER {
|
|
|
|
int id;
|
2003-08-15 20:35:44 +00:00
|
|
|
int create_time;
|
2002-08-26 22:57:17 +00:00
|
|
|
char email_addr[256];
|
|
|
|
char name[256];
|
|
|
|
char authenticator[256];
|
|
|
|
char country[256];
|
|
|
|
char postal_code[256];
|
2002-04-30 22:22:54 +00:00
|
|
|
double total_credit;
|
2002-09-27 06:12:50 +00:00
|
|
|
double expavg_credit; // credit per second, recent average
|
|
|
|
double expavg_time; // when the above was computed
|
2003-12-07 18:58:08 +00:00
|
|
|
char global_prefs[LARGE_BLOB_SIZE];
|
2003-03-19 21:01:32 +00:00
|
|
|
// global preferences, within <global_preferences> tag
|
2003-12-07 18:58:08 +00:00
|
|
|
char project_prefs[LARGE_BLOB_SIZE];
|
2003-10-26 06:14:15 +00:00
|
|
|
// project preferences; format:
|
|
|
|
// <project_preferences>
|
|
|
|
// <resource_share>X</resource_share>
|
|
|
|
// <project_specific>
|
|
|
|
// ...
|
|
|
|
// </project_specific>
|
|
|
|
// <venue name="x">
|
|
|
|
// <resource_share>x</resource_share>
|
|
|
|
// <project_specific>
|
|
|
|
// ...
|
|
|
|
// </project_specific>
|
|
|
|
// </venue>
|
|
|
|
// ...
|
|
|
|
// </project_preferences>
|
2003-03-20 02:05:25 +00:00
|
|
|
int teamid; // team ID if any
|
2003-02-18 23:07:48 +00:00
|
|
|
char venue[256]; // home/work/school (default)
|
2003-03-20 02:05:25 +00:00
|
|
|
char url[256]; // user's web page if any
|
|
|
|
bool send_email;
|
|
|
|
bool show_hosts;
|
2003-10-24 20:13:50 +00:00
|
|
|
int posts; // number of messages posted (redundant)
|
2006-07-05 21:38:08 +00:00
|
|
|
// deprecated as of 9/2004 - forum_preferences.posts is used instead
|
|
|
|
// may be used as a temp var (e.g. for mass email)
|
2003-10-24 20:13:50 +00:00
|
|
|
|
|
|
|
// The following are specific to SETI@home;
|
|
|
|
// they record info about the user's involvement in a prior project
|
|
|
|
int seti_id; // ID in old DB
|
|
|
|
int seti_nresults; // number of WUs completed
|
|
|
|
int seti_last_result_time; // time of last result (UNIX)
|
2003-10-31 21:26:12 +00:00
|
|
|
double seti_total_cpu; // number of CPU seconds
|
2003-11-28 23:11:22 +00:00
|
|
|
char signature[256];
|
2006-07-05 21:38:08 +00:00
|
|
|
// deprecated as of 9/2004 - may be used as temp
|
2003-12-15 02:31:29 +00:00
|
|
|
bool has_profile;
|
2004-04-18 18:40:13 +00:00
|
|
|
char cross_project_id[256];
|
2005-08-07 01:33:15 +00:00
|
|
|
char passwd_hash[256];
|
2006-12-27 18:22:17 +00:00
|
|
|
bool email_validated; // deprecated
|
2005-08-25 23:07:58 +00:00
|
|
|
int donated;
|
2003-06-04 17:21:26 +00:00
|
|
|
void clear();
|
2002-07-11 20:35:05 +00:00
|
|
|
};
|
|
|
|
|
2002-12-24 03:03:45 +00:00
|
|
|
#define TEAM_TYPE_CLUB 1
|
|
|
|
#define TEAM_TYPE_COMPANY 2
|
|
|
|
#define TEAM_TYPE_PRIMARY 3
|
|
|
|
#define TEAM_TYPE_SECONDARY 4
|
|
|
|
#define TEAM_TYPE_JUNIOR_COLLEGE 5
|
|
|
|
#define TEAM_TYPE_UNIVERSITY 6
|
|
|
|
#define TEAM_TYPE_GOVERNMENT 7
|
2002-07-11 20:35:05 +00:00
|
|
|
|
2003-12-12 21:10:39 +00:00
|
|
|
// invariants of teams:
|
|
|
|
// a team has > 0 members
|
|
|
|
|
2002-07-11 20:35:05 +00:00
|
|
|
struct TEAM {
|
|
|
|
int id;
|
2003-08-15 20:35:44 +00:00
|
|
|
int create_time;
|
2002-07-16 23:37:54 +00:00
|
|
|
int userid; // User ID of team founder
|
2002-08-26 22:57:17 +00:00
|
|
|
char name[256];
|
2002-07-16 23:37:54 +00:00
|
|
|
char name_lc[256]; // Team name in lowercase (used for searching)
|
2002-08-26 22:57:17 +00:00
|
|
|
char url[256];
|
|
|
|
int type; // Team type (see above)
|
|
|
|
char name_html[256];
|
2003-12-07 18:58:08 +00:00
|
|
|
char description[LARGE_BLOB_SIZE];
|
2003-01-30 23:03:52 +00:00
|
|
|
int nusers; // UNDEFINED BY DEFAULT
|
2002-12-24 03:03:45 +00:00
|
|
|
char country[256];
|
2004-01-14 20:24:24 +00:00
|
|
|
double total_credit;
|
|
|
|
double expavg_credit;
|
|
|
|
double expavg_time;
|
2003-10-24 20:13:50 +00:00
|
|
|
|
|
|
|
// The following is specific to SETI@home
|
|
|
|
int seti_id; // ID in old DB
|
2006-12-06 20:59:29 +00:00
|
|
|
int ping_user; // user who asked to become founder
|
|
|
|
int ping_time; // when they asked
|
|
|
|
|
2003-06-04 17:21:26 +00:00
|
|
|
void clear();
|
2002-04-30 22:22:54 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct HOST {
|
|
|
|
int id;
|
2003-08-15 20:35:44 +00:00
|
|
|
int create_time;
|
2002-07-16 23:37:54 +00:00
|
|
|
int userid; // ID of user running this host
|
2005-04-07 20:46:25 +00:00
|
|
|
// If the host is "zombied" during merging of duplicate hosts,
|
|
|
|
// this field is set to zero and rpc_seqno is used to
|
|
|
|
// store the ID of the new host (kludge, but what the heck)
|
2002-04-30 22:22:54 +00:00
|
|
|
int rpc_seqno; // last seqno received from client
|
2005-05-12 00:32:03 +00:00
|
|
|
// also used as a "forwarding ID" for zombied hosts (see above)
|
2003-08-15 20:35:44 +00:00
|
|
|
int rpc_time; // time of last scheduler RPC
|
2002-08-28 21:50:51 +00:00
|
|
|
double total_credit;
|
2002-09-25 19:40:19 +00:00
|
|
|
double expavg_credit; // credit per second, recent average
|
|
|
|
double expavg_time; // last time the above was updated
|
2002-04-30 22:22:54 +00:00
|
|
|
|
|
|
|
// all remaining items are assigned by the client
|
2005-05-05 05:23:45 +00:00
|
|
|
int timezone; // local STANDARD time at host - UTC time
|
|
|
|
// (in seconds)
|
2002-04-30 22:22:54 +00:00
|
|
|
char domain_name[256];
|
|
|
|
char serialnum[256];
|
2005-01-21 07:54:15 +00:00
|
|
|
char last_ip_addr[256]; // internal IP address as of last RPC
|
2003-07-01 20:37:09 +00:00
|
|
|
int nsame_ip_addr; // # of RPCs with same IP address
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2005-01-28 19:01:08 +00:00
|
|
|
double on_frac; // see client/time_stats.h
|
|
|
|
double connected_frac;
|
|
|
|
double active_frac;
|
2005-06-23 07:42:45 +00:00
|
|
|
double cpu_efficiency;
|
|
|
|
double duration_correction_factor;
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2002-07-16 23:37:54 +00:00
|
|
|
int p_ncpus; // Number of CPUs on host
|
2002-08-26 22:57:17 +00:00
|
|
|
char p_vendor[256]; // Vendor name of CPU
|
|
|
|
char p_model[256]; // Model of CPU
|
2002-09-26 05:57:10 +00:00
|
|
|
double p_fpops; // measured floating point ops/sec of CPU
|
|
|
|
double p_iops; // measured integer ops/sec of CPU
|
|
|
|
double p_membw; // measured memory bandwidth (bytes/sec) of CPU
|
2003-07-01 20:37:09 +00:00
|
|
|
// The above are per CPU, not total
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2002-08-26 22:57:17 +00:00
|
|
|
char os_name[256]; // Name of operating system
|
|
|
|
char os_version[256]; // Version of operating system
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2002-08-26 22:57:17 +00:00
|
|
|
double m_nbytes; // Size of memory in bytes
|
2002-07-16 23:37:54 +00:00
|
|
|
double m_cache; // Size of CPU cache in bytes (L1 or L2?)
|
2002-08-26 22:57:17 +00:00
|
|
|
double m_swap; // Size of swap space in bytes
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2005-10-04 21:44:58 +00:00
|
|
|
double d_total; // Total disk space on volume containing
|
|
|
|
// the BOINC client directory.
|
|
|
|
double d_free; // how much is free on that volume
|
|
|
|
|
|
|
|
// the following 2 items are reported in scheduler RPCs
|
|
|
|
// from clients w/ source Oct 4 2005 and later.
|
|
|
|
// NOTE: these items plus d_total and d_free are sufficient
|
|
|
|
// to avoid exceeding BOINC's limit on total disk space.
|
|
|
|
// But they are NOT sufficient to do resource-share-based
|
|
|
|
// disk space allocation.
|
|
|
|
// This needs to thought about.
|
|
|
|
//
|
2003-06-17 18:59:36 +00:00
|
|
|
double d_boinc_used_total;
|
2005-10-04 21:44:58 +00:00
|
|
|
// disk space being used in BOINC client dir,
|
|
|
|
// including all projects and BOINC itself
|
2003-06-17 18:59:36 +00:00
|
|
|
double d_boinc_used_project;
|
|
|
|
// amount being used for this project
|
2005-10-04 21:44:58 +00:00
|
|
|
|
|
|
|
// The following item is not used.
|
|
|
|
// It's redundant (server can compute based on other params and prefs)
|
|
|
|
//
|
|
|
|
double d_boinc_max; // max disk space that BOINC is allowed to use,
|
|
|
|
// reflecting user preferences
|
2002-12-26 17:24:33 +00:00
|
|
|
double n_bwup; // Average upload bandwidth, bytes/sec
|
|
|
|
double n_bwdown; // Average download bandwidth, bytes/sec
|
2003-06-18 20:52:17 +00:00
|
|
|
// The above are derived from actual
|
|
|
|
// file upload/download times, and may reflect
|
|
|
|
// factors other than network bandwidth
|
2002-04-30 22:22:54 +00:00
|
|
|
|
2002-09-25 19:40:19 +00:00
|
|
|
// The following is derived (by server) from other fields
|
|
|
|
double credit_per_cpu_sec;
|
|
|
|
|
2003-02-18 23:07:48 +00:00
|
|
|
char venue[256]; // home/work/school
|
2004-05-27 18:13:00 +00:00
|
|
|
int nresults_today; // results sent since midnight
|
2004-12-06 22:41:19 +00:00
|
|
|
double avg_turnaround; // recent average result turnaround time
|
2005-01-20 18:50:49 +00:00
|
|
|
char host_cpid[256]; // host cross-project ID
|
2005-01-21 07:54:15 +00:00
|
|
|
char external_ip_addr[256]; // IP address seen by scheduler
|
2005-02-26 00:24:37 +00:00
|
|
|
int max_results_day; // maximum # of results to send per day per CPU
|
|
|
|
// this is dynamically adjusted to limit work sent to bad hosts
|
2003-02-18 23:07:48 +00:00
|
|
|
|
2007-01-12 17:42:29 +00:00
|
|
|
// the following not stored in DB
|
|
|
|
//
|
|
|
|
double claimed_credit_per_cpu_sec;
|
|
|
|
|
2002-04-30 22:22:54 +00:00
|
|
|
int parse(FILE*);
|
|
|
|
int parse_time_stats(FILE*);
|
|
|
|
int parse_net_stats(FILE*);
|
2005-10-04 21:44:58 +00:00
|
|
|
int parse_disk_usage(FILE*);
|
2004-01-19 01:12:53 +00:00
|
|
|
void fix_nans();
|
2003-06-04 17:21:26 +00:00
|
|
|
void clear();
|
2002-04-30 22:22:54 +00:00
|
|
|
};
|
|
|
|
|
2002-12-17 19:00:43 +00:00
|
|
|
// values for file_delete state
|
|
|
|
#define FILE_DELETE_INIT 0
|
|
|
|
#define FILE_DELETE_READY 1
|
2003-09-21 21:00:25 +00:00
|
|
|
// set to this value only when we believe all files are uploaded
|
2002-12-17 19:00:43 +00:00
|
|
|
#define FILE_DELETE_DONE 2
|
2005-06-02 07:04:29 +00:00
|
|
|
// means the files were successfully deleted
|
2005-09-22 00:30:01 +00:00
|
|
|
#define FILE_DELETE_ERROR 3
|
2005-06-02 07:04:29 +00:00
|
|
|
// Any error was returned while attempting to delete the file
|
2002-12-17 19:00:43 +00:00
|
|
|
|
|
|
|
// values for assimilate_state
|
|
|
|
#define ASSIMILATE_INIT 0
|
|
|
|
#define ASSIMILATE_READY 1
|
|
|
|
#define ASSIMILATE_DONE 2
|
|
|
|
|
2003-06-04 17:21:26 +00:00
|
|
|
// NOTE: there is no overall state for a WU (like done/not done)
|
2003-01-23 08:07:48 +00:00
|
|
|
// There's just a bunch of independent substates
|
|
|
|
// (file delete, assimilate, and states of results, error flags)
|
|
|
|
|
|
|
|
// bit fields of error_mask
|
2003-08-15 20:35:44 +00:00
|
|
|
#define WU_ERROR_COULDNT_SEND_RESULT 1
|
|
|
|
#define WU_ERROR_TOO_MANY_ERROR_RESULTS 2
|
|
|
|
#define WU_ERROR_TOO_MANY_SUCCESS_RESULTS 4
|
|
|
|
#define WU_ERROR_TOO_MANY_TOTAL_RESULTS 8
|
2004-10-10 03:16:30 +00:00
|
|
|
#define WU_ERROR_CANCELLED 16
|
2002-11-05 18:36:09 +00:00
|
|
|
|
2002-04-30 22:22:54 +00:00
|
|
|
struct WORKUNIT {
|
|
|
|
int id;
|
2003-08-15 20:35:44 +00:00
|
|
|
int create_time;
|
2002-11-07 19:31:34 +00:00
|
|
|
int appid; // associated app
|
|
|
|
char name[256];
|
2004-05-13 18:18:22 +00:00
|
|
|
char xml_doc[LARGE_BLOB_SIZE];
|
2002-04-30 22:22:54 +00:00
|
|
|
int batch;
|
2003-09-04 00:41:51 +00:00
|
|
|
double rsc_fpops_est; // estimated # of FP operations
|
|
|
|
// used to estimate how long a result will take on a host
|
|
|
|
double rsc_fpops_bound; // upper bound on # of FP ops
|
|
|
|
// used to calculate an upper bound on the CPU time for a result
|
|
|
|
// before it is aborted.
|
|
|
|
double rsc_memory_bound; // upper bound on RAM working set (bytes)
|
2003-05-21 23:23:42 +00:00
|
|
|
// currently used only by scheduler to screen hosts
|
|
|
|
// At some point, could use as runtime limit
|
2003-09-04 00:41:51 +00:00
|
|
|
double rsc_disk_bound; // upper bound on amount of disk needed (bytes)
|
2003-05-21 23:23:42 +00:00
|
|
|
// (including input, output and temp files, but NOT the app)
|
2003-09-04 00:41:51 +00:00
|
|
|
// used for 2 purposes:
|
2003-05-21 23:23:42 +00:00
|
|
|
// 1) for scheduling (don't send this WU to a host w/ insuff. disk)
|
2003-09-04 00:41:51 +00:00
|
|
|
// 2) abort task if it uses more than this disk
|
2002-09-25 19:40:19 +00:00
|
|
|
bool need_validate; // this WU has at least 1 result in
|
2003-01-23 08:07:48 +00:00
|
|
|
// validate state = NEED_CHECK
|
2002-09-25 19:40:19 +00:00
|
|
|
int canonical_resultid; // ID of canonical result, or zero
|
|
|
|
double canonical_credit; // credit that all correct results get
|
2003-08-15 20:35:44 +00:00
|
|
|
int transition_time; // when should transition_handler
|
|
|
|
// next check this WU?
|
|
|
|
// MAXINT if no need to check
|
2003-01-23 08:07:48 +00:00
|
|
|
int delay_bound; // determines result deadline,
|
|
|
|
// timeout check time
|
|
|
|
int error_mask; // bitmask of errors (see above)
|
2002-12-17 19:00:43 +00:00
|
|
|
int file_delete_state;
|
|
|
|
int assimilate_state;
|
2004-12-06 22:41:19 +00:00
|
|
|
int hr_class; // homogeneous redundancy class
|
|
|
|
// used to send redundant copies only to "similar" hosts
|
|
|
|
// (in terms of numerics, performance, or both)
|
2003-12-12 21:10:39 +00:00
|
|
|
double opaque; // project-specific; usually external ID
|
2003-08-15 20:35:44 +00:00
|
|
|
int min_quorum; // minimum quorum size
|
|
|
|
int target_nresults; // try to get this many successful results
|
|
|
|
// may be > min_quorum to get consensus
|
|
|
|
// quicker or reflect loss rate
|
|
|
|
int max_error_results; // WU error if < #error results
|
|
|
|
int max_total_results; // WU error if < #total results
|
2004-11-22 19:17:13 +00:00
|
|
|
// (need this in case results are never returned)
|
2003-08-15 20:35:44 +00:00
|
|
|
int max_success_results; // WU error if < #success results
|
|
|
|
// without consensus (i.e. WU is nondeterministic)
|
2004-07-02 19:17:53 +00:00
|
|
|
char result_template_file[64];
|
2004-12-06 22:41:19 +00:00
|
|
|
int priority;
|
|
|
|
char mod_time[16];
|
2002-04-30 22:22:54 +00:00
|
|
|
|
|
|
|
// the following not used in the DB
|
|
|
|
char app_name[256];
|
2003-06-04 17:21:26 +00:00
|
|
|
void clear();
|
2002-04-30 22:22:54 +00:00
|
|
|
};
|
|
|
|
|
2003-09-27 23:20:40 +00:00
|
|
|
// WARNING: be Very careful about changing any values,
|
|
|
|
// especially for a project already running -
|
|
|
|
// the database will become inconsistent
|
2003-06-25 22:55:36 +00:00
|
|
|
|
2006-06-06 18:45:40 +00:00
|
|
|
//#define RESULT_SERVER_STATE_INACTIVE 1
|
2002-12-07 00:56:51 +00:00
|
|
|
#define RESULT_SERVER_STATE_UNSENT 2
|
2003-01-23 08:07:48 +00:00
|
|
|
#define RESULT_SERVER_STATE_IN_PROGRESS 4
|
|
|
|
#define RESULT_SERVER_STATE_OVER 5
|
|
|
|
// we received a reply, timed out, or decided not to send.
|
|
|
|
// Note: we could get a reply even after timing out.
|
|
|
|
|
|
|
|
#define RESULT_OUTCOME_INIT 0
|
|
|
|
#define RESULT_OUTCOME_SUCCESS 1
|
|
|
|
#define RESULT_OUTCOME_COULDNT_SEND 2
|
|
|
|
#define RESULT_OUTCOME_CLIENT_ERROR 3
|
2004-09-09 21:52:20 +00:00
|
|
|
// an error happened on the client
|
2003-01-23 08:07:48 +00:00
|
|
|
#define RESULT_OUTCOME_NO_REPLY 4
|
|
|
|
#define RESULT_OUTCOME_DIDNT_NEED 5
|
2003-06-25 22:55:36 +00:00
|
|
|
// we created the result but didn't need to send it because we already
|
2006-07-06 17:30:03 +00:00
|
|
|
// got a canonical result for the WU
|
2004-09-09 21:52:20 +00:00
|
|
|
#define RESULT_OUTCOME_VALIDATE_ERROR 6
|
2006-07-06 17:30:03 +00:00
|
|
|
// The outcome was initially SUCCESS,
|
|
|
|
// but the validator had a permanent error reading a result file,
|
2004-12-14 00:57:03 +00:00
|
|
|
// or the result file had a syntax error
|
2006-07-06 17:30:03 +00:00
|
|
|
#define RESULT_OUTCOME_CLIENT_DETACHED 7
|
|
|
|
// we believe that the client detached
|
2003-01-23 08:07:48 +00:00
|
|
|
|
|
|
|
#define VALIDATE_STATE_INIT 0
|
|
|
|
#define VALIDATE_STATE_VALID 1
|
|
|
|
#define VALIDATE_STATE_INVALID 2
|
2003-12-11 19:05:52 +00:00
|
|
|
#define VALIDATE_STATE_NO_CHECK 3
|
|
|
|
// WU had error, so we'll never get around to validating its results
|
|
|
|
// This lets us avoid showing the claimed credit as "pending"
|
2004-12-14 00:57:03 +00:00
|
|
|
#define VALIDATE_STATE_INCONCLUSIVE 4
|
|
|
|
// the validator looked this result (as part of a check_set() call)
|
|
|
|
// but didn't find a canonical result.
|
2005-02-08 00:39:05 +00:00
|
|
|
// This needs to be distinct from INIT for the transitioner to decide
|
|
|
|
// whether to trigger the validator
|
|
|
|
#define VALIDATE_STATE_TOO_LATE 5
|
|
|
|
// The result arrived after the canonical result's files were deleted,
|
|
|
|
// so we can't determine if it's valid
|
2002-09-25 19:40:19 +00:00
|
|
|
|
2002-04-30 22:22:54 +00:00
|
|
|
struct RESULT {
|
|
|
|
int id;
|
2003-08-15 20:35:44 +00:00
|
|
|
int create_time;
|
2002-08-26 22:57:17 +00:00
|
|
|
int workunitid;
|
2003-01-23 08:07:48 +00:00
|
|
|
int server_state; // see above
|
|
|
|
int outcome; // see above; defined if server state OVER
|
2003-06-25 22:55:36 +00:00
|
|
|
int client_state; // phase that client contacted us in.
|
2003-10-16 18:10:56 +00:00
|
|
|
// if UPLOADED then outcome is success.
|
2003-06-25 22:55:36 +00:00
|
|
|
// error details are in stderr_out.
|
|
|
|
// The values for this field are defined
|
|
|
|
// in lib/result_state.h
|
2002-09-26 05:57:10 +00:00
|
|
|
int hostid; // host processing this result
|
2003-10-16 18:10:56 +00:00
|
|
|
int userid; // user processing this result
|
2003-08-15 20:35:44 +00:00
|
|
|
int report_deadline; // deadline for receiving result
|
|
|
|
int sent_time; // when result was sent to host
|
|
|
|
int received_time; // when result was received from host
|
2002-08-26 22:57:17 +00:00
|
|
|
char name[256];
|
2002-09-26 05:57:10 +00:00
|
|
|
double cpu_time; // CPU time used to complete result
|
2004-05-13 18:18:22 +00:00
|
|
|
char xml_doc_in[LARGE_BLOB_SIZE]; // descriptions of output files
|
|
|
|
char xml_doc_out[LARGE_BLOB_SIZE]; // MD5s of output files
|
|
|
|
char stderr_out[LARGE_BLOB_SIZE]; // stderr output, if any
|
2002-04-30 22:22:54 +00:00
|
|
|
int batch;
|
2005-09-22 00:30:01 +00:00
|
|
|
int file_delete_state; // see above; values for file_delete_state
|
2002-09-25 19:40:19 +00:00
|
|
|
int validate_state;
|
2003-06-04 17:21:26 +00:00
|
|
|
double claimed_credit; // CPU time times host credit/sec
|
|
|
|
double granted_credit; // == canonical credit of WU
|
2003-12-12 21:10:39 +00:00
|
|
|
double opaque; // project-specific; usually external ID
|
2003-06-04 17:21:26 +00:00
|
|
|
int random; // determines send order
|
2004-01-14 20:24:24 +00:00
|
|
|
int app_version_num; // version# of app (not core client)
|
2003-11-11 20:49:07 +00:00
|
|
|
int appid; // copy of WU's appid
|
2003-12-23 19:21:52 +00:00
|
|
|
int exit_status; // application exit status, if any
|
2004-01-14 20:24:24 +00:00
|
|
|
int teamid;
|
2004-12-06 22:41:19 +00:00
|
|
|
int priority;
|
|
|
|
char mod_time[16];
|
2002-04-30 22:22:54 +00:00
|
|
|
|
|
|
|
// the following not used in the DB
|
|
|
|
char wu_name[256];
|
2005-06-24 04:34:45 +00:00
|
|
|
double fpops_per_cpu_sec;
|
|
|
|
double fpops_cumulative;
|
2005-11-03 05:31:21 +00:00
|
|
|
double intops_per_cpu_sec;
|
|
|
|
double intops_cumulative;
|
2002-04-30 22:22:54 +00:00
|
|
|
int parse_from_client(FILE*);
|
2003-06-04 17:21:26 +00:00
|
|
|
void clear();
|
2002-04-30 22:22:54 +00:00
|
|
|
};
|
|
|
|
|
2004-06-22 22:56:50 +00:00
|
|
|
struct MSG_FROM_HOST {
|
2004-01-04 06:48:40 +00:00
|
|
|
int id;
|
|
|
|
int create_time;
|
2004-05-12 21:21:09 +00:00
|
|
|
int hostid;
|
2004-07-06 04:10:51 +00:00
|
|
|
char variety[256]; // project-defined; what kind of msg
|
|
|
|
bool handled; // message handler has processed this
|
2006-01-24 21:38:03 +00:00
|
|
|
char xml[MSG_FROM_HOST_BLOB_SIZE];
|
2004-03-17 01:26:44 +00:00
|
|
|
void clear();
|
|
|
|
};
|
|
|
|
|
2004-06-22 22:56:50 +00:00
|
|
|
struct MSG_TO_HOST {
|
2004-03-17 01:26:44 +00:00
|
|
|
int id;
|
|
|
|
int create_time;
|
|
|
|
int hostid;
|
2004-07-06 04:10:51 +00:00
|
|
|
char variety[256]; // project-defined; what kind of msg
|
2004-03-17 01:26:44 +00:00
|
|
|
bool handled; // scheduler has sent this
|
2006-01-24 21:38:03 +00:00
|
|
|
char xml[MSG_TO_HOST_BLOB_SIZE]; // text to include in sched reply
|
2004-01-04 06:48:40 +00:00
|
|
|
void clear();
|
|
|
|
};
|
|
|
|
|
2004-07-01 20:24:00 +00:00
|
|
|
struct TRANSITIONER_ITEM {
|
2006-06-03 14:59:22 +00:00
|
|
|
int id; // WARNING: this is the WU ID
|
2004-07-01 18:43:36 +00:00
|
|
|
char name[256];
|
2004-12-06 22:41:19 +00:00
|
|
|
int appid;
|
|
|
|
int min_quorum;
|
2004-07-01 18:43:36 +00:00
|
|
|
bool need_validate;
|
2004-12-06 22:41:19 +00:00
|
|
|
int canonical_resultid;
|
|
|
|
int transition_time;
|
|
|
|
int delay_bound;
|
|
|
|
int error_mask;
|
|
|
|
int max_error_results;
|
|
|
|
int max_total_results;
|
|
|
|
int file_delete_state;
|
|
|
|
int assimilate_state;
|
|
|
|
int target_nresults;
|
2004-08-04 06:05:17 +00:00
|
|
|
char result_template_file[64];
|
2004-12-06 22:41:19 +00:00
|
|
|
int priority;
|
2006-01-26 00:19:05 +00:00
|
|
|
int batch;
|
2006-06-03 14:59:22 +00:00
|
|
|
int res_id; // This is the RESULT ID
|
2004-07-02 17:53:31 +00:00
|
|
|
char res_name[256];
|
2004-12-06 22:41:19 +00:00
|
|
|
int res_report_deadline;
|
|
|
|
int res_server_state;
|
|
|
|
int res_outcome;
|
|
|
|
int res_validate_state;
|
|
|
|
int res_file_delete_state;
|
|
|
|
int res_sent_time;
|
2004-12-16 21:58:10 +00:00
|
|
|
int res_hostid;
|
|
|
|
|
2004-07-01 18:43:36 +00:00
|
|
|
void clear();
|
2004-07-01 20:24:00 +00:00
|
|
|
void parse(MYSQL_ROW&);
|
2004-07-01 18:43:36 +00:00
|
|
|
};
|
|
|
|
|
2004-10-08 22:41:33 +00:00
|
|
|
struct VALIDATOR_ITEM {
|
2004-10-08 23:07:59 +00:00
|
|
|
WORKUNIT wu;
|
|
|
|
RESULT res;
|
2004-10-08 22:41:33 +00:00
|
|
|
|
2004-12-06 22:41:19 +00:00
|
|
|
void clear();
|
|
|
|
void parse(MYSQL_ROW&);
|
2004-10-08 22:41:33 +00:00
|
|
|
};
|
|
|
|
|
2003-06-04 17:21:26 +00:00
|
|
|
class DB_PLATFORM : public DB_BASE, public PLATFORM {
|
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_PLATFORM(DB_CONN* p=0);
|
2003-06-04 17:21:26 +00:00
|
|
|
int get_id();
|
|
|
|
void db_print(char*);
|
|
|
|
void db_parse(MYSQL_ROW &row);
|
|
|
|
};
|
|
|
|
|
|
|
|
class DB_APP : public DB_BASE, public APP {
|
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_APP(DB_CONN* p=0);
|
2003-06-04 17:21:26 +00:00
|
|
|
int get_id();
|
|
|
|
void db_print(char*);
|
|
|
|
void db_parse(MYSQL_ROW &row);
|
|
|
|
};
|
|
|
|
|
|
|
|
class DB_APP_VERSION : public DB_BASE, public APP_VERSION {
|
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_APP_VERSION(DB_CONN* p=0);
|
2003-06-04 17:21:26 +00:00
|
|
|
int get_id();
|
|
|
|
void db_print(char*);
|
|
|
|
void db_parse(MYSQL_ROW &row);
|
|
|
|
};
|
|
|
|
|
|
|
|
class DB_USER : public DB_BASE, public USER {
|
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_USER(DB_CONN* p=0);
|
2003-06-04 17:21:26 +00:00
|
|
|
int get_id();
|
|
|
|
void db_print(char*);
|
|
|
|
void db_parse(MYSQL_ROW &row);
|
|
|
|
void operator=(USER& r) {USER::operator=(r);}
|
|
|
|
};
|
|
|
|
|
|
|
|
class DB_TEAM : public DB_BASE, public TEAM {
|
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_TEAM(DB_CONN* p=0);
|
2003-06-04 17:21:26 +00:00
|
|
|
int get_id();
|
|
|
|
void db_print(char*);
|
|
|
|
void db_parse(MYSQL_ROW &row);
|
|
|
|
};
|
|
|
|
|
|
|
|
class DB_HOST : public DB_BASE, public HOST {
|
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_HOST(DB_CONN* p=0);
|
2003-06-04 17:21:26 +00:00
|
|
|
int get_id();
|
2005-05-03 21:50:51 +00:00
|
|
|
int update_diff(HOST&);
|
2003-06-04 17:21:26 +00:00
|
|
|
void db_print(char*);
|
|
|
|
void db_parse(MYSQL_ROW &row);
|
|
|
|
void operator=(HOST& r) {HOST::operator=(r);}
|
|
|
|
};
|
|
|
|
|
|
|
|
class DB_RESULT : public DB_BASE, public RESULT {
|
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_RESULT(DB_CONN* p=0);
|
2003-06-04 17:21:26 +00:00
|
|
|
int get_id();
|
2006-03-17 04:47:51 +00:00
|
|
|
int mark_as_sent(int old_server_state);
|
2003-06-04 17:21:26 +00:00
|
|
|
void db_print(char*);
|
2004-07-21 21:50:25 +00:00
|
|
|
void db_print_values(char*);
|
2003-06-04 17:21:26 +00:00
|
|
|
void db_parse(MYSQL_ROW &row);
|
|
|
|
void operator=(RESULT& r) {RESULT::operator=(r);}
|
|
|
|
};
|
|
|
|
|
|
|
|
class DB_WORKUNIT : public DB_BASE, public WORKUNIT {
|
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_WORKUNIT(DB_CONN* p=0);
|
2003-06-04 17:21:26 +00:00
|
|
|
int get_id();
|
|
|
|
void db_print(char*);
|
|
|
|
void db_parse(MYSQL_ROW &row);
|
2003-09-21 21:00:25 +00:00
|
|
|
void operator=(WORKUNIT& w) {WORKUNIT::operator=(w);}
|
2003-06-04 17:21:26 +00:00
|
|
|
};
|
|
|
|
|
2004-06-22 22:56:50 +00:00
|
|
|
class DB_MSG_FROM_HOST : public DB_BASE, public MSG_FROM_HOST {
|
2004-03-17 01:26:44 +00:00
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_MSG_FROM_HOST(DB_CONN* p=0);
|
2004-03-17 01:26:44 +00:00
|
|
|
int get_id();
|
|
|
|
void db_print(char*);
|
|
|
|
void db_parse(MYSQL_ROW &row);
|
|
|
|
};
|
|
|
|
|
2004-06-22 22:56:50 +00:00
|
|
|
class DB_MSG_TO_HOST : public DB_BASE, public MSG_TO_HOST {
|
2004-01-04 06:48:40 +00:00
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_MSG_TO_HOST(DB_CONN* p=0);
|
2004-01-04 06:48:40 +00:00
|
|
|
int get_id();
|
|
|
|
void db_print(char*);
|
|
|
|
void db_parse(MYSQL_ROW &row);
|
|
|
|
};
|
|
|
|
|
2004-07-01 20:24:00 +00:00
|
|
|
// The transitioner uses this to get (WU, result) pairs efficiently.
|
|
|
|
// Each call to enumerate() returns a list of the pairs for a single WU
|
|
|
|
//
|
|
|
|
class DB_TRANSITIONER_ITEM_SET : public DB_BASE_SPECIAL {
|
2004-07-01 18:43:36 +00:00
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_TRANSITIONER_ITEM_SET(DB_CONN* p=0);
|
2004-07-01 20:24:00 +00:00
|
|
|
TRANSITIONER_ITEM last_item;
|
2004-07-02 23:24:36 +00:00
|
|
|
int nitems_this_query;
|
2004-07-01 20:24:00 +00:00
|
|
|
|
|
|
|
int enumerate(
|
|
|
|
int transition_time,
|
|
|
|
int nresult_limit,
|
2005-08-11 23:53:24 +00:00
|
|
|
int wu_id_modulus,
|
|
|
|
int wu_id_remainder,
|
2004-07-01 20:24:00 +00:00
|
|
|
std::vector<TRANSITIONER_ITEM>& items
|
|
|
|
);
|
2004-07-02 19:45:33 +00:00
|
|
|
int update_result(TRANSITIONER_ITEM&);
|
2005-03-30 06:36:11 +00:00
|
|
|
int update_workunit(TRANSITIONER_ITEM&, TRANSITIONER_ITEM&);
|
2004-07-01 18:43:36 +00:00
|
|
|
};
|
|
|
|
|
2004-10-08 22:41:33 +00:00
|
|
|
// The validator uses this to get (WU, result) pairs efficiently.
|
|
|
|
// Each call to enumerate() returns a list of the pairs for a single WU
|
|
|
|
//
|
|
|
|
class DB_VALIDATOR_ITEM_SET : public DB_BASE_SPECIAL {
|
|
|
|
public:
|
|
|
|
DB_VALIDATOR_ITEM_SET(DB_CONN* p=0);
|
|
|
|
VALIDATOR_ITEM last_item;
|
|
|
|
int nitems_this_query;
|
|
|
|
|
|
|
|
int enumerate(
|
|
|
|
int appid,
|
|
|
|
int nresult_limit,
|
2005-02-22 20:12:31 +00:00
|
|
|
int wu_id_modulus,
|
|
|
|
int wu_id_remainder,
|
2004-10-08 22:41:33 +00:00
|
|
|
std::vector<VALIDATOR_ITEM>& items
|
|
|
|
);
|
|
|
|
int update_result(RESULT&);
|
|
|
|
int update_workunit(WORKUNIT&);
|
|
|
|
};
|
|
|
|
|
2004-07-02 22:48:33 +00:00
|
|
|
// used by the feeder and scheduler for outgoing work
|
|
|
|
//
|
|
|
|
struct WORK_ITEM {
|
2004-07-03 16:57:28 +00:00
|
|
|
int res_id;
|
|
|
|
WORKUNIT wu;
|
2004-07-02 22:48:33 +00:00
|
|
|
void parse(MYSQL_ROW& row);
|
|
|
|
};
|
|
|
|
|
|
|
|
class DB_WORK_ITEM : public WORK_ITEM, public DB_BASE_SPECIAL {
|
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_WORK_ITEM(DB_CONN* p=0);
|
2005-09-22 00:15:43 +00:00
|
|
|
int enumerate(
|
2006-05-02 22:33:00 +00:00
|
|
|
int limit, const char* select_clause, const char* order_clause
|
2005-09-22 00:30:01 +00:00
|
|
|
);
|
2004-07-02 22:48:33 +00:00
|
|
|
// used by feeder
|
|
|
|
int read_result();
|
|
|
|
// used by scheduler to read result server state
|
|
|
|
int update();
|
|
|
|
// used by scheduler to update WU transition time
|
|
|
|
// and various result fields
|
|
|
|
};
|
|
|
|
|
2004-12-05 23:52:17 +00:00
|
|
|
// Used by the scheduler to handle results reported by clients
|
|
|
|
// The read and the update of these results are combined
|
|
|
|
// into single SQL queries.
|
|
|
|
|
2004-07-06 18:30:22 +00:00
|
|
|
struct SCHED_RESULT_ITEM {
|
2004-12-05 23:52:17 +00:00
|
|
|
char queried_name[256]; // name as reported by client
|
2004-07-06 18:30:22 +00:00
|
|
|
int id;
|
|
|
|
char name[256];
|
|
|
|
int workunitid;
|
|
|
|
int server_state;
|
2004-07-02 22:48:33 +00:00
|
|
|
int client_state;
|
2004-07-06 18:30:22 +00:00
|
|
|
int validate_state;
|
|
|
|
int outcome;
|
|
|
|
int hostid;
|
|
|
|
int userid;
|
2004-07-02 22:48:33 +00:00
|
|
|
int teamid;
|
2005-06-26 19:34:17 +00:00
|
|
|
int sent_time;
|
2004-07-06 18:30:22 +00:00
|
|
|
int received_time;
|
|
|
|
double cpu_time;
|
|
|
|
double claimed_credit;
|
2004-07-02 22:48:33 +00:00
|
|
|
char xml_doc_out[LARGE_BLOB_SIZE];
|
2004-07-06 18:30:22 +00:00
|
|
|
char stderr_out[LARGE_BLOB_SIZE];
|
|
|
|
int app_version_num;
|
|
|
|
int exit_status;
|
2006-06-03 16:22:34 +00:00
|
|
|
int file_delete_state;
|
2004-07-02 22:48:33 +00:00
|
|
|
|
2004-07-06 18:30:22 +00:00
|
|
|
void clear();
|
|
|
|
void parse(MYSQL_ROW& row);
|
2004-07-02 22:48:33 +00:00
|
|
|
};
|
|
|
|
|
2004-07-06 18:30:22 +00:00
|
|
|
class DB_SCHED_RESULT_ITEM_SET : public DB_BASE_SPECIAL {
|
|
|
|
public:
|
2004-10-04 23:23:57 +00:00
|
|
|
DB_SCHED_RESULT_ITEM_SET(DB_CONN* p=0);
|
2004-07-06 19:04:37 +00:00
|
|
|
std::vector<SCHED_RESULT_ITEM> results;
|
2004-07-06 18:30:22 +00:00
|
|
|
|
|
|
|
int add_result(char* result_name);
|
|
|
|
|
|
|
|
int enumerate();
|
2004-12-05 23:52:17 +00:00
|
|
|
// using a single SQL query, look up all the reported results,
|
|
|
|
// (based on queried_name)
|
|
|
|
// and fill in the rest of the entries in the results vector
|
2004-07-06 18:30:22 +00:00
|
|
|
|
2004-07-27 23:29:27 +00:00
|
|
|
int lookup_result(char* result_name, SCHED_RESULT_ITEM** result);
|
2004-07-06 18:30:22 +00:00
|
|
|
|
|
|
|
int update_result(SCHED_RESULT_ITEM& result);
|
2004-07-21 23:48:56 +00:00
|
|
|
int update_workunits();
|
2004-07-02 22:48:33 +00:00
|
|
|
};
|
|
|
|
|
2002-04-30 22:22:54 +00:00
|
|
|
#endif
|