// This file is part of BOINC.
// http://boinc.berkeley.edu
// Copyright (C) 2012 University of California
//
// BOINC 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 3 of the License, or (at your option) any later version.
//
// BOINC 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.
//
// You should have received a copy of the GNU Lesser General Public License
// along with BOINC. If not, see .
// classes for volunteer data archival (VDA)
//
// Note: these classes are used by both the simulator (ssim.cpp)
// and the VDA server software (vdad.cpp, sched_vda.cpp)
#include
#include
#include
#include
#include "boinc_db.h"
#include "stats.h"
#include "vda_policy.h"
extern bool debug_status;
extern bool debug_ft;
// a host with rpc_time < now-HOST_TIMEOUT is considered dead.
// Make sure you set next_rpc_delay accordingly (e.g., to 86400)
//
#define VDA_HOST_TIMEOUT (86400*4)
extern void show_msg(char*);
extern char* time_str(double);
extern const char* status_str(int status);
inline bool outdated_client(HOST& h) {
char* p = strstr(h.serialnum, "BOINC|");
if (!p) return true;
int n = atoi(p + strlen("BOINC|"));
return (n < 7);
}
struct META_CHUNK;
struct VDA_FILE_AUX : VDA_FILE {
POLICY policy;
META_CHUNK* meta_chunk;
// the following for the simulator
//
double accounting_start_time;
STATS_ITEM disk_usage;
STATS_ITEM upload_rate;
STATS_ITEM download_rate;
STATS_ITEM fault_tolerance;
int pending_init_downloads;
// # of initial downloads pending.
// When this is zero, we start collecting stats for the file
inline bool collecting_stats() {
return (pending_init_downloads == 0);
}
VDA_FILE_AUX(){
meta_chunk = NULL;
}
// the following for vdad
//
DB_HOST enum_host;
char enum_query[256];
int max_chunks;
int last_id;
bool enum_active;
bool found_this_scan;
bool found_any_this_scan;
bool found_any_this_enum;
int init();
int get_state();
int choose_host();
VDA_FILE_AUX(DB_VDA_FILE f) : VDA_FILE(f) {
max_chunks = 0;
enum_active = false;
last_id = 0;
}
};
#define PRESENT 0
// this unit is present on the server
// (in the case of meta-chunks, this means that enough chunks
// to reconstruct the meta-chunk are present on the server)
#define RECOVERABLE 1
// this unit is not present, but could be recovered from data on clients
#define UNRECOVERABLE 2
// not present or recoverable
// base class for chunks and meta-chunks
//
struct DATA_UNIT {
virtual void recovery_plan(){};
virtual int recovery_action(double){return 0;};
virtual int compute_min_failures(){return 0;};
virtual int upload_all(){return 0;};
char name[64];
char dir[1024];
// the following are determined during recovery_plan()
// and used during recovery_action()
//
int status;
bool in_recovery_set;
// if we need to reconstruct the parent, we'll use this unit
bool data_now_present;
// vdad: this unit was initially unrecoverable,
// but the parent has become present so now this unit is present
bool data_needed;
// this unit is not currently present;
// we need to take action (e.g. start uploads)
// to make it present
double cost;
bool keep_present;
// this unit is present and we need to keep it present
bool need_present;
// delete this??
int min_failures;
// min # of host failures that would make this unrecoverable
int delete_file();
// delete the file on server corresponding to this unit
};
struct META_CHUNK : DATA_UNIT {
std::vector children;
META_CHUNK* parent;
int n_children_present;
bool have_unrecoverable_children;
VDA_FILE_AUX* dfile;
CODING coding;
bool bottom_level;
bool need_reconstruct;
bool needed_by_parent;
double child_size;
// used by ssim
META_CHUNK(
VDA_FILE_AUX* d, META_CHUNK* par, double size,
int coding_level, int index
);
// used by vdad
META_CHUNK(VDA_FILE_AUX* d, META_CHUNK* p, int index);
int init(const char* dir, POLICY&, int level);
int get_state(const char* dir, POLICY&, int level);
virtual void recovery_plan();
virtual int recovery_action(double);
virtual int compute_min_failures();
virtual int upload_all();
int decide_reconstruct();
int reconstruct_and_cleanup();
int expand();
bool some_child_is_unrecoverable() {
for (unsigned int i=0; i hosts;
META_CHUNK* parent;
double size;
bool present_on_server;
CHUNK(META_CHUNK* mc, double s, int index);
int start_upload();
void host_failed(VDA_CHUNK_HOST* p);
bool download_in_progress();
void upload_complete();
void download_complete();
int assign();
virtual void recovery_plan();
virtual int recovery_action(double);
virtual int compute_min_failures();
virtual int upload_all();
bool need_more_replicas() {
return ((int)hosts.size() < parent->dfile->policy.replication);
}
// used by vda
void print_status(int indent_level);
// used by vdad
int start_upload_from_host(VDA_CHUNK_HOST&);
};
// names
//
// chunk name: c1.c2.cn
// (in VDA_CHUNK_HOST)
//
// chunk/file name: c1.c2.cn_filename.ext
//
// physical file name: vda_hostid_c1.c2.cn_filename.ext
inline void physical_file_name(
int hostid, char* chunk_name, char* file_name, char* buf
) {
sprintf(buf, "vda_%d_%s_%s", hostid, chunk_name, file_name);
}
inline void physical_file_name(
int hostid, char* chunk_file_name, char* buf
) {
sprintf(buf, "vda_%d_%s", hostid, chunk_file_name);
}
//
// download WU/result name: download_vda_c1.c2.cn_filename.ext
//
// upload WU/result name: upload_vda_c1.c2.cn_filename.ext