Signal::Processing::IInvalidator::ptr Step::
mark_as_crashed_and_get_invalidator()
{
if (died_)
return Signal::Processing::IInvalidator::ptr();
DEBUGINFO TaskInfo ti(boost::format("Marking step \"%s\" as crashed") % operation_name());
died_ = operation_desc_;
operation_desc_ = Signal::OperationDesc::ptr(new Test::TransparentOperationDesc);
return died_.read ()->getInvalidator ();
}
int Step::
registerTask(Interval expected_output)
{
TASKINFO TaskInfo ti(format("Step::registerTask %2% on %1%")
% operation_name()
% expected_output);
++task_counter_;
if (0 == task_counter_)
++task_counter_;
int taskid = task_counter_;
running_tasks[taskid] = expected_output;
not_started_ -= expected_output;
return taskid;
}
void error_logger::handle_alert(alert const* a)
{
if (m_file == NULL) return;
time_t now = time(NULL);
char timestamp[256];
strncpy(timestamp, ctime(&now), sizeof(timestamp));
for (int i = 0; i < sizeof(timestamp); ++i)
{
if (timestamp[i] != '\n' && timestamp[i] != '\r') continue;
timestamp[i] = '\0';
break;
}
switch (a->type())
{
case peer_error_alert::alert_type:
{
peer_error_alert const* pe = alert_cast<peer_error_alert>(a);
#ifdef TORRENT_USE_OPENSSL
// unknown protocol
if (pe->error != error_code(336027900, boost::asio::error::get_ssl_category()))
#endif
{
fprintf(m_file, "%s\terror [%s] (%s:%d) %s\n", timestamp
, print_endpoint(pe->ip).c_str(), pe->error.category().name()
, pe->error.value(), pe->error.message().c_str());
}
break;
}
case peer_disconnected_alert::alert_type:
{
peer_disconnected_alert const* pd = alert_cast<peer_disconnected_alert>(a);
if (pd
&& pd->error != boost::system::errc::connection_reset
&& pd->error != boost::system::errc::connection_aborted
&& pd->error != boost::system::errc::connection_refused
&& pd->error != boost::system::errc::timed_out
&& pd->error != boost::asio::error::eof
&& pd->error != boost::asio::error::host_unreachable
&& pd->error != boost::asio::error::network_unreachable
&& pd->error != boost::asio::error::broken_pipe
#ifdef TORRENT_USE_OPENSSL
// unknown protocol
&& pd->error != error_code(336027900, boost::asio::error::get_ssl_category())
#endif
&& pd->error != error_code(libtorrent::errors::self_connection)
&& pd->error != error_code(libtorrent::errors::torrent_removed)
&& pd->error != error_code(libtorrent::errors::torrent_aborted)
&& pd->error != error_code(libtorrent::errors::stopping_torrent)
&& pd->error != error_code(libtorrent::errors::session_closing)
&& pd->error != error_code(libtorrent::errors::duplicate_peer_id)
&& pd->error != error_code(libtorrent::errors::timed_out)
&& pd->error != error_code(libtorrent::errors::timed_out_no_handshake)
&& pd->error != error_code(libtorrent::errors::upload_upload_connection))
fprintf(m_file, "%s\tdisconnect [%s][%s] (%s:%d) %s\n", timestamp
, print_endpoint(pd->ip).c_str(), operation_name(pd->operation)
, pd->error.category().name(), pd->error.value(), pd->error.message().c_str());
break;
}
case save_resume_data_failed_alert::alert_type:
{
save_resume_data_failed_alert const* rs= alert_cast<save_resume_data_failed_alert>(a);
if (rs)
fprintf(m_file, "%s\tsave-resume-failed (%s:%d) %s\n", timestamp
, rs->error.category().name(), rs->error.value()
, rs->message().c_str());
}
case torrent_delete_failed_alert::alert_type:
{
torrent_delete_failed_alert const* td = alert_cast<torrent_delete_failed_alert>(a);
if (td)
fprintf(m_file, "%s\tstorage-delete-failed (%s:%d) %s\n", timestamp
, td->error.category().name(), td->error.value()
, td->message().c_str());
}
case storage_moved_failed_alert::alert_type:
{
storage_moved_failed_alert const* sm = alert_cast<storage_moved_failed_alert>(a);
if (sm)
fprintf(m_file, "%s\tstorage-move-failed (%s:%d) %s\n", timestamp
, sm->error.category().name(), sm->error.value()
, sm->message().c_str());
}
case file_rename_failed_alert::alert_type:
{
file_rename_failed_alert const* rn = alert_cast<file_rename_failed_alert>(a);
if (rn)
fprintf(m_file, "%s\tfile-rename-failed (%s:%d) %s\n", timestamp
, rn->error.category().name(), rn->error.value()
, rn->message().c_str());
}
case torrent_error_alert::alert_type:
{
torrent_error_alert const* te = alert_cast<torrent_error_alert>(a);
if (te)
fprintf(m_file, "%s\ttorrent-error (%s:%d) %s\n", timestamp
, te->error.category().name(), te->error.value()
, te->message().c_str());
}
case hash_failed_alert::alert_type:
{
hash_failed_alert const* hf = alert_cast<hash_failed_alert>(a);
if (hf)
fprintf(m_file, "%s\thash-failed %s\n", timestamp
, hf->message().c_str());
}
case file_error_alert::alert_type:
{
file_error_alert const* fe = alert_cast<file_error_alert>(a);
if (fe)
fprintf(m_file, "%s\tfile-error (%s:%d) %s\n", timestamp
, fe->error.category().name(), fe->error.value()
, fe->message().c_str());
}
case metadata_failed_alert::alert_type:
{
metadata_failed_alert const* mf = alert_cast<metadata_failed_alert>(a);
if (mf)
fprintf(m_file, "%s\tmetadata-error (%s:%d) %s\n", timestamp
, mf->error.category().name(), mf->error.value()
, mf->message().c_str());
}
case udp_error_alert::alert_type:
{
udp_error_alert const* ue = alert_cast<udp_error_alert>(a);
if (ue)
fprintf(m_file, "%s\tudp-error (%s:%d) %s %s\n", timestamp
, ue->error.category().name(), ue->error.value()
, print_endpoint(ue->endpoint).c_str()
, ue->error.message().c_str());
}
case listen_failed_alert::alert_type:
{
listen_failed_alert const* lf = alert_cast<listen_failed_alert>(a);
if (lf)
fprintf(m_file, "%s\tlisten-error (%s:%d) %s\n", timestamp
, lf->error.category().name(), lf->error.value()
, lf->message().c_str());
}
case rss_alert::alert_type:
{
rss_alert const* ra = alert_cast<rss_alert>(a);
if (ra && ra->state == rss_alert::state_error)
fprintf(m_file, "%s\trss-error (%s:%d) %s %s\n", timestamp
, ra->error.category().name(), ra->error.value()
, ra->error.message().c_str()
, ra->url.c_str());
}
case invalid_request_alert::alert_type:
{
invalid_request_alert const* ira = alert_cast<invalid_request_alert>(a);
if (ira)
fprintf(m_file, "%s\tinvalid-request %s\n", timestamp
, ira->message().c_str());
}
case mmap_cache_alert::alert_type:
{
mmap_cache_alert const* ma = alert_cast<mmap_cache_alert>(a);
if (ma)
fprintf(m_file, "%s\tmmap-cache-error (%s:%d )%s\n", timestamp
, ma->error.category().name(), ma->error.value()
, ma->message().c_str());
}
}
}
static enum agent_return do_operation(enum operation op, const char *name)
{
TDB_DATA k;
enum agent_return ret;
TDB_DATA data;
enum TDB_ERROR ecode;
union tdb_attribute cif;
if (op != OPEN && op != OPEN_WITH_HOOK && !tdb) {
diag("external: No tdb open!");
return OTHER_FAILURE;
}
diag("external: %s", operation_name(op));
k = tdb_mkdata(name, strlen(name));
locking_would_block = 0;
switch (op) {
case OPEN:
if (tdb) {
diag("Already have tdb %s open", tdb_name(tdb));
return OTHER_FAILURE;
}
tdb = tdb_open(name, TDB_DEFAULT, O_RDWR, 0, &tap_log_attr);
if (!tdb) {
if (!locking_would_block)
diag("Opening tdb gave %s", strerror(errno));
forget_locking();
ret = OTHER_FAILURE;
} else
ret = SUCCESS;
break;
case OPEN_WITH_HOOK:
if (tdb) {
diag("Already have tdb %s open", tdb_name(tdb));
return OTHER_FAILURE;
}
cif.openhook.base.attr = TDB_ATTRIBUTE_OPENHOOK;
cif.openhook.base.next = &tap_log_attr;
cif.openhook.fn = clear_if_first;
tdb = tdb_open(name, TDB_DEFAULT, O_RDWR, 0, &cif);
if (!tdb) {
if (!locking_would_block)
diag("Opening tdb gave %s", strerror(errno));
forget_locking();
ret = OTHER_FAILURE;
} else
ret = SUCCESS;
break;
case FETCH:
ecode = tdb_fetch(tdb, k, &data);
if (ecode == TDB_ERR_NOEXIST) {
ret = FAILED;
} else if (ecode < 0) {
ret = OTHER_FAILURE;
} else if (!tdb_deq(data, k)) {
ret = OTHER_FAILURE;
external_agent_free(data.dptr);
} else {
ret = SUCCESS;
external_agent_free(data.dptr);
}
break;
case STORE:
ret = tdb_store(tdb, k, k, 0) == 0 ? SUCCESS : OTHER_FAILURE;
break;
case TRANSACTION_START:
ret = tdb_transaction_start(tdb) == 0 ? SUCCESS : OTHER_FAILURE;
break;
case TRANSACTION_COMMIT:
ret = tdb_transaction_commit(tdb)==0 ? SUCCESS : OTHER_FAILURE;
break;
case NEEDS_RECOVERY:
ret = external_agent_needs_rec(tdb);
break;
case CHECK:
ret = tdb_check(tdb, NULL, NULL) == 0 ? SUCCESS : OTHER_FAILURE;
break;
case CLOSE:
ret = tdb_close(tdb) == 0 ? SUCCESS : OTHER_FAILURE;
tdb = NULL;
break;
case SEND_SIGNAL:
/* We do this async */
ret = SUCCESS;
break;
default:
ret = OTHER_FAILURE;
}
if (locking_would_block)
ret = WOULD_HAVE_BLOCKED;
return ret;
}
static enum agent_return do_operation(enum operation op, const char *name)
{
NTDB_DATA k, d;
enum agent_return ret;
NTDB_DATA data;
enum NTDB_ERROR ecode;
union ntdb_attribute cif;
const char *eq;
if (op != OPEN && op != OPEN_WITH_HOOK && !ntdb) {
diag("external: No ntdb open!");
return OTHER_FAILURE;
}
diag("external: %s", operation_name(op));
eq = strchr(name, '=');
if (eq) {
k = ntdb_mkdata(name, eq - name);
d = ntdb_mkdata(eq + 1, strlen(eq+1));
} else {
k = ntdb_mkdata(name, strlen(name));
d.dsize = 0;
d.dptr = NULL;
}
locking_would_block = 0;
switch (op) {
case OPEN:
if (ntdb) {
diag("Already have ntdb %s open", ntdb_name(ntdb));
return OTHER_FAILURE;
}
ntdb = ntdb_open(name, MAYBE_NOSYNC, O_RDWR, 0, &tap_log_attr);
if (!ntdb) {
if (!locking_would_block)
diag("Opening ntdb gave %s", strerror(errno));
forget_locking();
ret = OTHER_FAILURE;
} else
ret = SUCCESS;
break;
case OPEN_WITH_HOOK:
if (ntdb) {
diag("Already have ntdb %s open", ntdb_name(ntdb));
return OTHER_FAILURE;
}
cif.openhook.base.attr = NTDB_ATTRIBUTE_OPENHOOK;
cif.openhook.base.next = &tap_log_attr;
cif.openhook.fn = clear_if_first;
ntdb = ntdb_open(name, MAYBE_NOSYNC, O_RDWR, 0, &cif);
if (!ntdb) {
if (!locking_would_block)
diag("Opening ntdb gave %s", strerror(errno));
forget_locking();
ret = OTHER_FAILURE;
} else
ret = SUCCESS;
break;
case FETCH:
ecode = ntdb_fetch(ntdb, k, &data);
if (ecode == NTDB_ERR_NOEXIST) {
ret = FAILED;
} else if (ecode < 0) {
ret = OTHER_FAILURE;
} else if (!ntdb_deq(data, d)) {
ret = OTHER_FAILURE;
external_agent_free(data.dptr);
} else {
ret = SUCCESS;
external_agent_free(data.dptr);
}
break;
case STORE:
ret = ntdb_store(ntdb, k, d, 0) == 0 ? SUCCESS : OTHER_FAILURE;
break;
case TRANSACTION_START:
ret = ntdb_transaction_start(ntdb) == 0 ? SUCCESS : OTHER_FAILURE;
break;
case TRANSACTION_COMMIT:
ret = ntdb_transaction_commit(ntdb)==0 ? SUCCESS : OTHER_FAILURE;
break;
case NEEDS_RECOVERY:
ret = external_agent_needs_rec(ntdb);
break;
case CHECK:
ret = ntdb_check(ntdb, NULL, NULL) == 0 ? SUCCESS : OTHER_FAILURE;
break;
case CLOSE:
ret = ntdb_close(ntdb) == 0 ? SUCCESS : OTHER_FAILURE;
ntdb = NULL;
break;
case SEND_SIGNAL:
/* We do this async */
ret = SUCCESS;
break;
default:
ret = OTHER_FAILURE;
}
if (locking_would_block)
ret = WOULD_HAVE_BLOCKED;
return ret;
}