You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdenetwork/kget/slave.cpp

332 lines
8.7 KiB

/***************************************************************************
* slave.cpp
* -------------------
*
* Revision : $Id$
* begin : Tue Jan 29 2002
* copyright : (C) 2002 by Patrick Charbonnier
* : Based On Caitoo v.0.7.3 (c) 1998 - 2000, Matej Koss
* email : pch@freeshell.org
*
****************************************************************************/
/***************************************************************************
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
***************************************************************************/
#include <kapplication.h>
#include <kio/scheduler.h>
#include "getfilejob.h"
#include "slave.h"
#include "slaveevent.h"
#include "transfer.h"
#include <assert.h>
Slave::Slave(Transfer * _parent, const KURL & _src, const KURL & _dest)
: TQObject(),
TQThread()
{
mDebug << ">>>>Entering" << endl;
copyjob = NULL;
m_src = _src;
m_dest = _dest;
m_parent = _parent;
nPendingCommand = 0;
mDebug << ">>>>Leaving" << endl;
}
Slave::~Slave()
{}
void Slave::Op(SlaveCommand _cmd)
{
mDebugIn << " _cmd = " << _cmd << endl;
if ( !running() ) // start on demand
start();
mutex.lock();
stack.push(_cmd);
nPendingCommand++;
worker.wakeOne();
mutex.unlock();
mDebugOut << endl;
}
/** No descriptions */
void Slave::PostMessage(SlaveResult _event, TQ_ULLONG _data)
{
SlaveEvent *e1 = new SlaveEvent(m_parent, _event, _data);
TQApplication::postEvent(kapp->mainWidget(), (TQEvent *) e1);
}
void Slave::PostMessage(SlaveResult _event, const TQString & _msg)
{
SlaveEvent *e1 = new SlaveEvent(m_parent, _event, _msg);
TQApplication::postEvent(kapp->mainWidget(), (TQEvent *) e1);
mDebug << "Msg:" << "_msg = " << _msg << endl;
}
void Slave::InfoMessage(const TQString & _msg)
{
SlaveEvent *e1 = new SlaveEvent(m_parent, SLV_INFO, _msg);
TQApplication::postEvent(kapp->mainWidget(), (TQEvent *) e1);
mDebug << "Infor Msg:" << "_msg = " << _msg << endl;
}
void Slave::run()
{
mDebugIn << endl;
SlaveCommand cmd;
bool running = true;
while (running)
{
if (!nPendingCommand)
worker.wait();
switch (cmd = fetch_cmd())
{
case RESTART:
if (copyjob) {
copyjob->kill(true);
copyjob = 0L;
}
// fall through
case RETR:
mDebug << " FETCHED COMMAND RETR" << endl;
assert(!copyjob);
KIO::Scheduler::checkSlaveOnHold( true );
copyjob = new KIO::GetFileJob(m_src, m_dest);
Connect();
PostMessage(SLV_RESUMED);
break;
case RETR_CACHE:
mDebug << " FETCHED COMMAND RETR_CACHE" << endl;
assert(!copyjob);
KIO::Scheduler::checkSlaveOnHold( true );
copyjob = new KIO::GetFileJob(m_src, m_dest);
copyjob->addMetaData("cache", "cacheonly");
Connect();
break;
case PAUSE:
mDebug << " FETCHED COMMAND PAUSE" << endl;
if (copyjob) {
copyjob->kill(true);
copyjob = 0L;
}
PostMessage(SLV_PAUSED);
break;
case KILL:
mDebug << " FETCHED COMMAND KILL" << endl;
running = false;
if (copyjob) {
copyjob->kill(true);
copyjob = 0L;
}
// no message posted
break;
case REMOVE:
mDebug << " FETCHED COMMAND REMOVE" << endl;
running = false;
if (copyjob) {
copyjob->kill(true);
copyjob = 0L;
}
PostMessage(SLV_REMOVED);
break;
case SCHEDULE:
mDebug << " FETCHED COMMAND SCHEDULE" << endl;
if (copyjob) {
copyjob->kill(true);
copyjob = 0L;
}
PostMessage(SLV_SCHEDULED);
break;
case DELAY:
mDebug << " FETCHED COMMAND DELAY" << endl;
if (copyjob) {
copyjob->kill(true);
copyjob = 0L;
}
PostMessage(SLV_DELAYED);
break;
case NOOP:
mDebug << "FETCHED COMMAND NOOP, i.e. empty stack" << endl;
if (copyjob) {
copyjob->kill(true);
copyjob = 0L;
}
running = false;
break;
default:
mDebug << " UNKNOWN COMMAND DIE...." << endl;
assert(0);
}
}
assert(!copyjob);
mDebugOut << endl;
}
Slave::SlaveCommand Slave::fetch_cmd()
{
mutex.lock();
SlaveCommand cmd = NOOP;
if ( !stack.isEmpty() )
{
nPendingCommand--;
cmd = stack.pop();
}
mutex.unlock();
return cmd;
}
void Slave::Connect()
{
mDebugIn << endl;
connect(copyjob, TQT_SIGNAL(canceled(KIO::Job *)), TQT_SLOT(slotCanceled(KIO::Job *)));
connect(copyjob, TQT_SIGNAL(connected(KIO::Job *)), TQT_SLOT(slotConnected(KIO::Job *)));
connect(copyjob, TQT_SIGNAL(result(KIO::Job *)), TQT_SLOT(slotResult(KIO::Job *)));
connect(copyjob, TQT_SIGNAL(totalSize(KIO::Job *, KIO::filesize_t)), TQT_SLOT(slotTotalSize(KIO::Job *, KIO::filesize_t)));
connect(copyjob, TQT_SIGNAL(processedSize(KIO::Job *, KIO::filesize_t)), TQT_SLOT(slotProcessedSize(KIO::Job *, KIO::filesize_t)));
connect(copyjob, TQT_SIGNAL(speed(KIO::Job *, unsigned long)), TQT_SLOT(slotSpeed(KIO::Job *, unsigned long)));
connect(copyjob, TQT_SIGNAL(infoMessage(KIO::Job *, const TQString &)), TQT_SLOT(slotInfoMessage(KIO::Job *, const TQString &)));
mDebugOut << endl;
}
void Slave::slotCanceled(KIO::Job *)
{
mDebugIn << endl;
mDebugOut << endl;
}
void Slave::slotConnected(KIO::Job *)
{
mDebugIn << endl;
mDebugOut << endl;
}
void Slave::slotResult(KIO::Job * job)
{
mDebugIn << endl;
assert(copyjob == job);
copyjob=0L;
KIO::Error error=KIO::Error(job->error());
if (!error) {
PostMessage(SLV_FINISHED);
}
else {
if (m_parent->getMode() == Transfer::MD_NEW)
{
PostMessage(SLV_NOTINCACHE);
return;
}
TQString tmsg="<font color=\"red\"> <b>" + job->errorString() + \
"</b></font>";
InfoMessage(tmsg);
if (m_parent->retryOnError() && \
((error==KIO::ERR_COULD_NOT_LOGIN) || (error==KIO::ERR_SERVER_TIMEOUT))) {
//Timeout or login error
PostMessage(SLV_ERROR);
}
else if (m_parent->retryOnBroken() && (error==KIO::ERR_CONNECTION_BROKEN)) {
// Connection Broken
PostMessage(SLV_BROKEN);
}
else {
job->showErrorDialog();
PostMessage(SLV_DELAYED);
}
}
mDebugOut << endl;
}
void Slave::slotSpeed(KIO::Job *, unsigned long lSpeed)
{
// mDebugIn<<endl;
PostMessage(SLV_PROGRESS_SPEED, lSpeed);
// mDebugOut<<endl;
}
void Slave::slotTotalSize(KIO::Job *, KIO::filesize_t _total_size)
{
mDebugIn << "= " << _total_size << endl;
if ((int)_total_size == 0)//shouldn't happen, but does
return;
if (m_parent->getMode() != Transfer::MD_NEW)
{
PostMessage(SLV_CAN_RESUME, copyjob->getCanResume());
PostMessage(SLV_CONNECTED);
}
else
InfoMessage("checking if file is in cache...yes");
PostMessage(SLV_TOTAL_SIZE, _total_size);
mDebugOut << endl;
}
void Slave::slotProcessedSize(KIO::Job *, KIO::filesize_t _processed_size)
{
// mDebugIn<<endl;
PostMessage(SLV_PROGRESS_SIZE, _processed_size);
// mDebugOut<<endl;
}
void Slave::slotInfoMessage(KIO::Job *, const TQString & _msg)
{
mDebugIn << "MSG=" << _msg << endl;
InfoMessage(_msg);
mDebugOut << endl;
}
#include "slave.moc"