2003-07-01 20:37:09 +00:00
|
|
|
// The contents of this file are subject to the BOINC Public License
|
2002-06-10 06:14:18 +00:00
|
|
|
// Version 1.0 (the "License"); you may not use this file except in
|
|
|
|
// compliance with the License. You may obtain a copy of the License at
|
2003-07-01 20:37:09 +00:00
|
|
|
// http://boinc.berkeley.edu/license_1.0.txt
|
2003-07-02 02:05:44 +00:00
|
|
|
//
|
2002-06-10 06:14:18 +00:00
|
|
|
// Software distributed under the License is distributed on an "AS IS"
|
|
|
|
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
|
|
|
|
// License for the specific language governing rights and limitations
|
2003-07-02 02:05:44 +00:00
|
|
|
// under the License.
|
|
|
|
//
|
|
|
|
// The Original Code is the Berkeley Open Infrastructure for Network Computing.
|
|
|
|
//
|
2002-06-10 06:14:18 +00:00
|
|
|
// The Initial Developer of the Original Code is the SETI@home project.
|
2003-07-01 20:37:09 +00:00
|
|
|
// Portions created by the SETI@home project are Copyright (C) 2002
|
2003-07-02 02:05:44 +00:00
|
|
|
// University of California at Berkeley. All Rights Reserved.
|
|
|
|
//
|
2002-06-10 06:14:18 +00:00
|
|
|
// Contributor(s):
|
|
|
|
//
|
|
|
|
|
2003-10-16 19:03:49 +00:00
|
|
|
#include "cpp.h"
|
2002-08-09 21:43:19 +00:00
|
|
|
|
2004-03-04 11:41:43 +00:00
|
|
|
#ifdef _WIN32
|
2004-06-16 23:16:08 +00:00
|
|
|
#include "boinc_win.h"
|
2004-03-04 11:41:43 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef _WIN32
|
2004-07-13 13:54:09 +00:00
|
|
|
#include <cmath>
|
|
|
|
#include <cstdlib>
|
2004-03-04 11:41:43 +00:00
|
|
|
#endif
|
2002-08-07 22:52:10 +00:00
|
|
|
|
|
|
|
#include "error_numbers.h"
|
2003-06-16 21:23:58 +00:00
|
|
|
#include "md5_file.h"
|
2002-08-07 22:52:10 +00:00
|
|
|
#include "parse.h"
|
|
|
|
#include "util.h"
|
2003-08-01 21:20:20 +00:00
|
|
|
#include "filesys.h"
|
2002-08-07 22:52:10 +00:00
|
|
|
|
2004-04-08 08:15:23 +00:00
|
|
|
#include "log_flags.h"
|
|
|
|
#include "file_names.h"
|
|
|
|
#include "client_state.h"
|
|
|
|
#include "client_types.h"
|
|
|
|
#include "client_msgs.h"
|
|
|
|
|
2004-06-30 18:17:21 +00:00
|
|
|
using std::vector;
|
|
|
|
|
2002-06-10 06:14:18 +00:00
|
|
|
// PERS_FILE_XFER represents a persistent file transfer.
|
2002-08-20 00:30:13 +00:00
|
|
|
// A set of URLs is given.
|
2003-02-26 00:47:57 +00:00
|
|
|
//
|
2002-06-10 06:14:18 +00:00
|
|
|
// For download, the object attempts to download the file
|
|
|
|
// from any of the URLs.
|
|
|
|
// If one fails or is not available, try another,
|
|
|
|
// using an exponential backoff policy to avoid flooding servers.
|
2003-02-26 00:47:57 +00:00
|
|
|
//
|
2002-06-10 06:14:18 +00:00
|
|
|
// For upload, try to upload the file to the first URL;
|
|
|
|
// if that fails try the others.
|
2003-02-04 21:47:12 +00:00
|
|
|
|
|
|
|
PERS_FILE_XFER::PERS_FILE_XFER() {
|
2002-08-07 22:52:10 +00:00
|
|
|
nretry = 0;
|
2002-12-06 07:33:45 +00:00
|
|
|
first_request_time = time(0);
|
2002-08-07 22:52:10 +00:00
|
|
|
next_request_time = first_request_time;
|
2003-02-06 03:39:10 +00:00
|
|
|
time_so_far = 0;
|
2003-07-23 22:24:28 +00:00
|
|
|
fip = NULL;
|
|
|
|
fxp = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
PERS_FILE_XFER::~PERS_FILE_XFER() {
|
|
|
|
if (fip) {
|
|
|
|
fip->pers_file_xfer = NULL;
|
|
|
|
}
|
2003-02-04 21:47:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int PERS_FILE_XFER::init(FILE_INFO* f, bool is_file_upload) {
|
|
|
|
fxp = NULL;
|
|
|
|
fip = f;
|
2002-08-07 22:52:10 +00:00
|
|
|
is_upload = is_file_upload;
|
|
|
|
xfer_done = false;
|
2004-07-06 18:31:56 +00:00
|
|
|
char* p = f->get_init_url(is_file_upload);
|
|
|
|
if (!p) {
|
|
|
|
msg_printf(NULL, MSG_ERROR, "No URL for file transfer of %s", f->name);
|
|
|
|
return ERR_NULL;
|
|
|
|
}
|
2002-08-07 22:52:10 +00:00
|
|
|
return 0;
|
2002-06-10 06:14:18 +00:00
|
|
|
}
|
|
|
|
|
2002-08-07 22:52:10 +00:00
|
|
|
// Try to start the file transfer associated with this persistent file transfer.
|
|
|
|
//
|
2003-05-16 19:22:57 +00:00
|
|
|
int PERS_FILE_XFER::start_xfer() {
|
2002-08-07 22:52:10 +00:00
|
|
|
FILE_XFER *file_xfer;
|
|
|
|
int retval;
|
2003-02-26 00:47:57 +00:00
|
|
|
|
2004-04-08 08:15:23 +00:00
|
|
|
SCOPE_MSG_LOG scope_messages(log_messages, CLIENT_MSG_LOG::DEBUG_FILE_XFER);
|
2003-07-02 02:02:18 +00:00
|
|
|
|
2002-08-07 22:52:10 +00:00
|
|
|
// Decide whether to start a new file transfer
|
2002-08-14 20:31:27 +00:00
|
|
|
//
|
2003-12-02 22:47:32 +00:00
|
|
|
if (!gstate.start_new_file_xfer(*this)) {
|
2003-05-16 19:22:57 +00:00
|
|
|
return ERR_IDLE_PERIOD;
|
2002-08-21 19:12:42 +00:00
|
|
|
}
|
2003-06-09 23:50:49 +00:00
|
|
|
|
2003-08-01 21:20:20 +00:00
|
|
|
// Does the file exist already? this could happen for example if we are
|
2003-12-02 22:47:32 +00:00
|
|
|
// downloading an application which exists from a previous installation
|
|
|
|
//
|
2003-08-01 21:20:20 +00:00
|
|
|
if (!is_upload) {
|
|
|
|
char pathname[256];
|
|
|
|
get_pathname(fip, pathname);
|
|
|
|
double existing_size = 0;
|
|
|
|
if (!file_size(pathname, existing_size) && existing_size == fip->nbytes) {
|
|
|
|
// file exists already and has the right size
|
|
|
|
retval = verify_downloaded_file(pathname, *fip);
|
|
|
|
if (!retval) {
|
|
|
|
// signature and checksum match
|
|
|
|
retval = fip->set_permissions();
|
|
|
|
fip->status = FILE_PRESENT;
|
|
|
|
xfer_done = true;
|
|
|
|
|
|
|
|
msg_printf(
|
2003-12-02 22:47:32 +00:00
|
|
|
fip->project, MSG_INFO,
|
|
|
|
"File %s exists already, skipping download", pathname
|
|
|
|
);
|
2004-07-13 13:54:09 +00:00
|
|
|
|
2003-08-01 21:20:20 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-08-21 19:12:42 +00:00
|
|
|
// Create a new FILE_XFER object and initialize a
|
|
|
|
// download or upload for the persistent file transfer
|
|
|
|
//
|
|
|
|
file_xfer = new FILE_XFER;
|
2004-03-27 00:45:27 +00:00
|
|
|
file_xfer->set_proxy(&gstate.pi);
|
2002-08-21 19:12:42 +00:00
|
|
|
if (is_upload) {
|
2003-03-31 23:18:55 +00:00
|
|
|
if (gstate.exit_before_upload) {
|
|
|
|
exit(0);
|
|
|
|
}
|
2002-08-21 19:12:42 +00:00
|
|
|
retval = file_xfer->init_upload(*fip);
|
|
|
|
} else {
|
|
|
|
retval = file_xfer->init_download(*fip);
|
|
|
|
}
|
2004-06-03 21:19:18 +00:00
|
|
|
fxp = file_xfer;
|
2002-08-21 19:12:42 +00:00
|
|
|
if (retval) {
|
2003-07-03 05:01:29 +00:00
|
|
|
msg_printf(
|
|
|
|
fip->project, MSG_ERROR, "Couldn't start %s for %s: error %d",
|
2004-07-06 17:37:58 +00:00
|
|
|
(is_upload ? "upload" : "download"), fip->get_current_url(is_upload), retval
|
2003-07-03 05:01:29 +00:00
|
|
|
);
|
2003-05-20 00:03:39 +00:00
|
|
|
handle_xfer_failure();
|
2004-07-27 23:29:45 +00:00
|
|
|
delete fxp;
|
|
|
|
fxp = NULL;
|
2003-05-16 19:22:57 +00:00
|
|
|
return retval;
|
2003-03-13 21:49:52 +00:00
|
|
|
// TODO: do we need to do anything here?
|
2003-05-16 19:22:57 +00:00
|
|
|
}
|
|
|
|
retval = gstate.file_xfers->insert(file_xfer);
|
|
|
|
if (retval) {
|
2003-07-03 05:01:29 +00:00
|
|
|
msg_printf(
|
|
|
|
fip->project, MSG_ERROR, "Couldn't start %s for %s: error %d",
|
2004-07-06 17:37:58 +00:00
|
|
|
(is_upload ? "upload" : "download"), fip->get_current_url(is_upload), retval
|
2003-07-03 05:01:29 +00:00
|
|
|
);
|
2003-05-16 19:22:57 +00:00
|
|
|
fxp->file_xfer_retval = retval;
|
2003-05-20 00:03:39 +00:00
|
|
|
handle_xfer_failure();
|
|
|
|
delete fxp;
|
2003-05-16 19:22:57 +00:00
|
|
|
fxp = NULL;
|
|
|
|
return retval;
|
2002-08-07 22:52:10 +00:00
|
|
|
}
|
2003-05-16 19:22:57 +00:00
|
|
|
if (log_flags.file_xfer) {
|
2003-07-03 05:01:29 +00:00
|
|
|
msg_printf(
|
|
|
|
fip->project, MSG_INFO, "Started %s of %s",
|
|
|
|
(is_upload ? "upload" : "download"), fip->name
|
|
|
|
);
|
2003-05-16 19:22:57 +00:00
|
|
|
}
|
2004-07-06 17:37:58 +00:00
|
|
|
scope_messages.printf("PERS_FILE_XFER::start_xfer(): URL: %s\n",fip->get_current_url(is_upload));
|
2003-05-16 19:22:57 +00:00
|
|
|
return 0;
|
2002-06-10 06:14:18 +00:00
|
|
|
}
|
|
|
|
|
2002-08-14 20:31:27 +00:00
|
|
|
// Poll the status of this persistent file transfer.
|
|
|
|
// If it's time to start it, then attempt to start it.
|
|
|
|
// If it has finished or failed, then deal with it appropriately
|
2002-08-07 22:52:10 +00:00
|
|
|
//
|
2003-03-16 21:59:11 +00:00
|
|
|
bool PERS_FILE_XFER::poll(time_t now) {
|
2002-08-07 22:52:10 +00:00
|
|
|
int retval;
|
2004-07-06 17:37:58 +00:00
|
|
|
char pathname[256];
|
|
|
|
double existing_size = 0;
|
2003-06-09 23:50:49 +00:00
|
|
|
|
2004-04-08 08:15:23 +00:00
|
|
|
SCOPE_MSG_LOG scope_messages(log_messages, CLIENT_MSG_LOG::DEBUG_FILE_XFER);
|
2003-07-02 02:02:18 +00:00
|
|
|
|
2002-08-22 00:16:04 +00:00
|
|
|
if (xfer_done) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (!fxp) {
|
2002-08-14 20:31:27 +00:00
|
|
|
// No file xfer is active.
|
2003-12-02 22:47:32 +00:00
|
|
|
// Either initial or resume after failure.
|
2002-08-14 20:31:27 +00:00
|
|
|
// See if it's time to try again.
|
|
|
|
//
|
2003-03-16 21:59:11 +00:00
|
|
|
if (now >= next_request_time) {
|
2003-02-04 21:47:12 +00:00
|
|
|
last_time = dtime();
|
2003-05-16 19:22:57 +00:00
|
|
|
fip->upload_offset = -1;
|
|
|
|
retval = start_xfer();
|
|
|
|
return (retval == 0);
|
2002-08-14 20:31:27 +00:00
|
|
|
} else {
|
2002-08-20 00:30:13 +00:00
|
|
|
return false;
|
|
|
|
}
|
2002-08-14 20:31:27 +00:00
|
|
|
}
|
2002-08-07 22:52:10 +00:00
|
|
|
|
2003-02-26 00:47:57 +00:00
|
|
|
if (dtime() - last_time <= 2) {
|
2003-02-04 21:47:12 +00:00
|
|
|
time_so_far += dtime() - last_time;
|
|
|
|
}
|
|
|
|
last_time = dtime();
|
2003-02-03 22:47:08 +00:00
|
|
|
|
2002-08-14 20:31:27 +00:00
|
|
|
if (fxp->file_xfer_done) {
|
2004-07-06 18:31:56 +00:00
|
|
|
// check if the file was actually downloaded, if not check if there are more urls to try
|
|
|
|
// if there are no bytes downloaded, than the was probably a wrong url downloaded
|
2004-07-06 17:37:58 +00:00
|
|
|
get_pathname(fip, pathname);
|
2004-07-14 21:28:59 +00:00
|
|
|
file_size(pathname, existing_size);
|
|
|
|
if (existing_size != fip->nbytes) {
|
|
|
|
check_giveup("File downloaded was not the correct file or was garbage from bad URL");
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
scope_messages.printf(
|
|
|
|
"PERS_FILE_XFER::poll(): file transfer status %d",
|
|
|
|
fxp->file_xfer_retval
|
|
|
|
);
|
|
|
|
if (fxp->file_xfer_retval == 0) {
|
|
|
|
// The transfer finished with no errors.
|
|
|
|
if (log_flags.file_xfer) {
|
|
|
|
msg_printf(
|
|
|
|
fip->project, MSG_INFO, "Finished %s of %s",
|
|
|
|
is_upload?"upload":"download", fip->name
|
|
|
|
);
|
|
|
|
if (fxp->xfer_speed < 0) {
|
|
|
|
msg_printf(fip->project, MSG_INFO, "No data transferred");
|
|
|
|
} else {
|
2004-07-06 18:31:56 +00:00
|
|
|
msg_printf(
|
2004-07-14 21:28:59 +00:00
|
|
|
fip->project, MSG_INFO, "Approximate throughput %f bytes/sec",
|
|
|
|
fxp->xfer_speed
|
2004-07-06 18:31:56 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
2004-07-14 21:28:59 +00:00
|
|
|
xfer_done = true;
|
|
|
|
} else if (fxp->file_xfer_retval == ERR_UPLOAD_PERMANENT) {
|
|
|
|
if (log_flags.file_xfer) {
|
|
|
|
msg_printf(
|
|
|
|
fip->project, MSG_INFO, "Permanently failed %s of %s",
|
|
|
|
is_upload?"upload":"download", fip->name
|
|
|
|
);
|
|
|
|
}
|
|
|
|
check_giveup("server rejected file");
|
|
|
|
} else {
|
|
|
|
if (log_flags.file_xfer) {
|
|
|
|
msg_printf(
|
|
|
|
fip->project, MSG_INFO, "Temporarily failed %s of %s",
|
|
|
|
is_upload?"upload":"download", fip->name
|
|
|
|
);
|
|
|
|
}
|
|
|
|
handle_xfer_failure();
|
|
|
|
}
|
|
|
|
// remove fxp from file_xfer_set and deallocate it
|
|
|
|
//
|
|
|
|
gstate.file_xfers->remove(fxp);
|
|
|
|
delete fxp;
|
|
|
|
fxp = NULL;
|
2004-07-06 18:31:56 +00:00
|
|
|
|
2004-07-14 21:28:59 +00:00
|
|
|
return true;
|
2004-07-06 17:37:58 +00:00
|
|
|
}
|
2002-06-10 06:14:18 +00:00
|
|
|
}
|
2002-08-07 22:52:10 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2004-07-27 23:29:45 +00:00
|
|
|
// Takes a reason why a transfer has failed.
|
|
|
|
//
|
|
|
|
// Checks to see if there are no more valid URLs listed in the file_info.
|
|
|
|
//
|
|
|
|
// If no more urls are present, the file is then given up on, the reason is
|
|
|
|
// listed in the error_msg field, and the appropriate status code is given.
|
|
|
|
//
|
|
|
|
// If there are more URLs to try, the file_xfer is restarted with these new
|
|
|
|
// urls until a good transfer is made or it completely gives up.
|
2004-07-06 17:37:58 +00:00
|
|
|
//
|
|
|
|
void PERS_FILE_XFER::check_giveup(char* why) {
|
2004-07-27 23:29:45 +00:00
|
|
|
if(fip->get_next_url(fip->upload_when_present) == NULL) {
|
|
|
|
// the file has no appropriate download location
|
|
|
|
// remove the file from the directory and delete the file xfer object
|
|
|
|
gstate.file_xfers->remove(fxp);
|
|
|
|
delete fxp;
|
|
|
|
fxp = NULL;
|
|
|
|
// apply the correct error code
|
|
|
|
if (is_upload) {
|
|
|
|
fip->status = ERR_GIVEUP_UPLOAD;
|
|
|
|
} else {
|
|
|
|
fip->status = ERR_GIVEUP_DOWNLOAD;
|
|
|
|
}
|
|
|
|
// end the xfer so it will be deleted
|
|
|
|
xfer_done = true;
|
|
|
|
msg_printf(
|
|
|
|
fip->project, MSG_ERROR, "Giving up on %s of %s: %s",
|
|
|
|
is_upload?"upload":"download", fip->name, why
|
|
|
|
);
|
|
|
|
fip->error_msg = why;
|
|
|
|
// delete the associated file in the project directory
|
|
|
|
fip->delete_file();
|
|
|
|
} else {
|
|
|
|
if (is_upload) {
|
|
|
|
if (gstate.exit_before_upload) {
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
fxp->init_upload(*fip);
|
|
|
|
} else {
|
|
|
|
fxp->init_download(*fip);
|
|
|
|
}
|
|
|
|
}
|
2003-05-06 21:43:26 +00:00
|
|
|
}
|
|
|
|
|
2002-08-21 19:12:42 +00:00
|
|
|
// Handle a transfer failure
|
|
|
|
//
|
2003-05-20 00:03:39 +00:00
|
|
|
void PERS_FILE_XFER::handle_xfer_failure() {
|
|
|
|
time_t now = time(0);
|
2003-03-13 21:49:52 +00:00
|
|
|
|
2002-08-21 19:12:42 +00:00
|
|
|
// If it was a bad range request, delete the file and start over
|
2003-03-13 21:49:52 +00:00
|
|
|
//
|
2002-08-26 22:57:17 +00:00
|
|
|
if (fxp->file_xfer_retval == HTTP_STATUS_RANGE_REQUEST_ERROR) {
|
2002-08-21 19:12:42 +00:00
|
|
|
fip->delete_file();
|
2004-07-27 23:29:45 +00:00
|
|
|
return;
|
2002-08-21 19:12:42 +00:00
|
|
|
}
|
2003-02-04 21:47:12 +00:00
|
|
|
|
2003-09-30 18:09:58 +00:00
|
|
|
if (fxp->file_xfer_retval == HTTP_STATUS_NOT_FOUND) {
|
2004-06-17 02:36:08 +00:00
|
|
|
// If it is uploading and receives a HTTP_STATUS_NOT_FOUND then
|
|
|
|
// the file upload handler could not be found.
|
|
|
|
if (!fxp->is_upload) {
|
2004-07-06 17:37:58 +00:00
|
|
|
check_giveup("file was not found on server");
|
2004-06-17 02:36:08 +00:00
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
retry_or_backoff();
|
2004-07-27 23:29:45 +00:00
|
|
|
return;
|
2004-06-17 02:36:08 +00:00
|
|
|
}
|
2003-09-30 18:09:58 +00:00
|
|
|
}
|
2003-06-09 23:50:49 +00:00
|
|
|
|
2002-08-21 19:12:42 +00:00
|
|
|
// See if it's time to give up on the persistent file xfer
|
|
|
|
//
|
2003-05-20 00:03:39 +00:00
|
|
|
if ((now - first_request_time) > gstate.file_xfer_giveup_period) {
|
2004-07-06 17:37:58 +00:00
|
|
|
check_giveup("too much elapsed time");
|
2003-09-30 18:09:58 +00:00
|
|
|
} else {
|
|
|
|
retry_or_backoff();
|
2002-08-30 20:56:02 +00:00
|
|
|
}
|
2002-08-21 19:12:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Cycle to the next URL, or if we've hit all URLs in this cycle,
|
|
|
|
// backoff and try again later
|
|
|
|
//
|
2003-05-20 00:03:39 +00:00
|
|
|
void PERS_FILE_XFER::retry_or_backoff() {
|
2003-06-09 23:50:49 +00:00
|
|
|
// struct tm *newtime;
|
2003-05-20 00:03:39 +00:00
|
|
|
time_t now;
|
2003-06-03 22:47:15 +00:00
|
|
|
int backoff = 0;
|
2003-06-09 23:50:49 +00:00
|
|
|
|
2004-04-08 08:15:23 +00:00
|
|
|
SCOPE_MSG_LOG scope_messages(log_messages, CLIENT_MSG_LOG::DEBUG_FILE_XFER);
|
2003-07-02 02:02:18 +00:00
|
|
|
|
2003-05-20 00:03:39 +00:00
|
|
|
now = time(0);
|
2003-06-09 23:50:49 +00:00
|
|
|
// newtime = localtime(&now);
|
2003-02-26 00:47:57 +00:00
|
|
|
|
2002-08-21 19:12:42 +00:00
|
|
|
// Cycle to the next URL to try
|
|
|
|
// If we reach the URL that we started at, then we have tried all
|
|
|
|
// servers without success
|
2003-02-26 00:47:57 +00:00
|
|
|
//
|
2004-07-06 18:31:56 +00:00
|
|
|
|
|
|
|
if (fip->get_next_url(is_upload) == NULL) {
|
2002-08-21 19:12:42 +00:00
|
|
|
nretry++;
|
2003-02-26 00:47:57 +00:00
|
|
|
|
|
|
|
// Do an exponential backoff of e^nretry seconds,
|
2003-06-11 22:15:25 +00:00
|
|
|
// keeping within the bounds of pers_retry_delay_min and
|
|
|
|
// pers_retry_delay_max
|
2003-02-26 00:47:57 +00:00
|
|
|
//
|
2003-07-03 05:01:29 +00:00
|
|
|
backoff = calculate_exponential_backoff(
|
|
|
|
"pers_file_xfer",
|
|
|
|
nretry, gstate.pers_retry_delay_min, gstate.pers_retry_delay_max
|
|
|
|
);
|
2003-06-03 17:52:28 +00:00
|
|
|
next_request_time = now + backoff;
|
2002-08-21 19:12:42 +00:00
|
|
|
}
|
2003-10-21 18:18:41 +00:00
|
|
|
msg_printf(fip->project, MSG_INFO,
|
|
|
|
"Backing off %s on transfer of file %s",
|
|
|
|
timediff_format(backoff).c_str(), fip->name
|
|
|
|
);
|
2002-08-21 19:12:42 +00:00
|
|
|
}
|
|
|
|
|
2002-08-07 22:52:10 +00:00
|
|
|
// Parse XML information about a single persistent file transfer
|
|
|
|
//
|
2004-06-12 04:45:36 +00:00
|
|
|
int PERS_FILE_XFER::parse(MIOFILE& fin) {
|
2003-06-03 22:47:15 +00:00
|
|
|
char buf[256];
|
2002-08-15 22:03:41 +00:00
|
|
|
|
2004-06-12 04:45:36 +00:00
|
|
|
while (fin.fgets(buf, 256)) {
|
2002-08-07 22:52:10 +00:00
|
|
|
if (match_tag(buf, "</persistent_file_xfer>")) return 0;
|
|
|
|
else if (parse_int(buf, "<num_retries>", nretry)) continue;
|
|
|
|
else if (parse_int(buf, "<first_request_time>", first_request_time)) continue;
|
|
|
|
else if (parse_int(buf, "<next_request_time>", next_request_time)) continue;
|
2003-02-03 22:47:08 +00:00
|
|
|
else if (parse_double(buf, "<time_so_far>", time_so_far)) continue;
|
2003-03-13 21:49:52 +00:00
|
|
|
else {
|
2003-06-03 22:47:15 +00:00
|
|
|
msg_printf(fip->project, MSG_ERROR, "PERS_FILE_XFER::parse(): unrecognized: %s", buf);
|
2003-03-13 21:49:52 +00:00
|
|
|
}
|
2002-08-07 22:52:10 +00:00
|
|
|
}
|
2003-10-21 18:18:41 +00:00
|
|
|
return ERR_XML_PARSE;
|
2002-08-07 22:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Write XML information about a particular persistent file transfer
|
|
|
|
//
|
2004-06-12 04:45:36 +00:00
|
|
|
int PERS_FILE_XFER::write(MIOFILE& fout) {
|
|
|
|
fout.printf(
|
2002-08-20 00:30:13 +00:00
|
|
|
" <persistent_file_xfer>\n"
|
|
|
|
" <num_retries>%d</num_retries>\n"
|
|
|
|
" <first_request_time>%d</first_request_time>\n"
|
|
|
|
" <next_request_time>%d</next_request_time>\n"
|
2003-02-03 22:47:08 +00:00
|
|
|
" <time_so_far>%f</time_so_far>\n"
|
2002-08-20 00:30:13 +00:00
|
|
|
" </persistent_file_xfer>\n",
|
2003-02-03 22:47:08 +00:00
|
|
|
nretry, first_request_time, next_request_time, time_so_far
|
2002-08-14 20:31:27 +00:00
|
|
|
);
|
2004-01-31 23:21:07 +00:00
|
|
|
if (fxp) {
|
2004-06-12 04:45:36 +00:00
|
|
|
fout.printf(
|
2004-01-31 23:21:07 +00:00
|
|
|
" <file_xfer>\n"
|
|
|
|
" <bytes_xferred>%f</bytes_xferred>\n"
|
|
|
|
" <file_offset>%f</file_offset>\n"
|
|
|
|
" <xfer_speed>%f</xfer_speed>\n"
|
2004-02-15 19:22:01 +00:00
|
|
|
" <hostname>%s</hostname>\n"
|
2004-01-31 23:21:07 +00:00
|
|
|
" </file_xfer>\n",
|
|
|
|
fxp->bytes_xferred,
|
|
|
|
fxp->file_offset,
|
|
|
|
fxp->xfer_speed,
|
2004-02-05 22:36:55 +00:00
|
|
|
fxp->get_hostname()
|
2004-01-31 23:21:07 +00:00
|
|
|
);
|
|
|
|
}
|
2002-08-07 22:52:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2003-07-29 23:26:32 +00:00
|
|
|
void PERS_FILE_XFER::suspend() {
|
|
|
|
if (fxp) {
|
|
|
|
if (fxp->socket) {
|
|
|
|
fxp->close_socket();
|
|
|
|
fxp->socket = 0;
|
|
|
|
}
|
|
|
|
if (fxp->file) {
|
|
|
|
fclose(fxp->file);
|
|
|
|
fxp->file = 0;
|
|
|
|
}
|
|
|
|
gstate.file_xfers->remove(fxp); // this removes from http_op_set too
|
|
|
|
delete fxp;
|
|
|
|
fxp = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-08-07 22:52:10 +00:00
|
|
|
PERS_FILE_XFER_SET::PERS_FILE_XFER_SET(FILE_XFER_SET* p) {
|
|
|
|
file_xfers = p;
|
2002-06-10 06:14:18 +00:00
|
|
|
}
|
|
|
|
|
2002-08-21 19:12:42 +00:00
|
|
|
// Run through the set, starting any transfers that need to be
|
|
|
|
// started and deleting any that have finished
|
|
|
|
//
|
2002-08-12 00:51:42 +00:00
|
|
|
bool PERS_FILE_XFER_SET::poll() {
|
2002-08-07 22:52:10 +00:00
|
|
|
unsigned int i;
|
2002-06-10 06:14:18 +00:00
|
|
|
bool action = false;
|
2002-12-06 07:33:45 +00:00
|
|
|
int now = time(0);
|
2002-06-10 06:14:18 +00:00
|
|
|
|
|
|
|
for (i=0; i<pers_file_xfers.size(); i++) {
|
2002-08-07 22:52:10 +00:00
|
|
|
action |= pers_file_xfers[i]->poll(now);
|
|
|
|
}
|
|
|
|
|
2002-08-22 21:29:58 +00:00
|
|
|
if (action) gstate.set_client_state_dirty("pers_file_xfer_set poll");
|
2002-08-21 19:12:42 +00:00
|
|
|
|
2002-08-07 22:52:10 +00:00
|
|
|
return action;
|
|
|
|
}
|
|
|
|
|
2002-08-14 20:31:27 +00:00
|
|
|
// Insert a PERS_FILE_XFER object into the set.
|
|
|
|
// We will decide which ones to start when we hit the polling loop
|
2002-08-07 22:52:10 +00:00
|
|
|
//
|
|
|
|
int PERS_FILE_XFER_SET::insert(PERS_FILE_XFER* pfx) {
|
|
|
|
pers_file_xfers.push_back(pfx);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-08-14 20:31:27 +00:00
|
|
|
// Remove a PERS_FILE_XFER object from the set.
|
|
|
|
// What should the action here be?
|
2002-08-07 22:52:10 +00:00
|
|
|
//
|
|
|
|
int PERS_FILE_XFER_SET::remove(PERS_FILE_XFER* pfx) {
|
|
|
|
vector<PERS_FILE_XFER*>::iterator iter;
|
|
|
|
|
|
|
|
iter = pers_file_xfers.begin();
|
|
|
|
while (iter != pers_file_xfers.end()) {
|
|
|
|
if (*iter == pfx) {
|
|
|
|
pers_file_xfers.erase(iter);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
iter++;
|
2002-06-10 06:14:18 +00:00
|
|
|
}
|
2003-06-03 22:47:15 +00:00
|
|
|
msg_printf(
|
|
|
|
pfx->fip->project, MSG_ERROR,
|
|
|
|
"PERS_FILE_XFER_SET::remove(): not found"
|
2003-05-14 21:17:58 +00:00
|
|
|
);
|
2004-01-30 22:19:19 +00:00
|
|
|
return ERR_NOT_FOUND;
|
2002-06-10 06:14:18 +00:00
|
|
|
}
|
2003-07-29 23:26:32 +00:00
|
|
|
|
|
|
|
// suspend all PERS_FILE_XFERs
|
|
|
|
//
|
|
|
|
void PERS_FILE_XFER_SET::suspend() {
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i=0; i<pers_file_xfers.size(); i++) {
|
|
|
|
pers_file_xfers[i]->suspend();
|
|
|
|
}
|
|
|
|
}
|