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.
tdelibs/kio/kio/scheduler.h

365 lines
13 KiB

// -*- c++ -*-
/* This file is part of the KDE libraries
Copyright (C) 2000 Stephan Kulow <coolo@kde.org>
Waldo Bastian <bastian@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef _kio_scheduler_h
#define _kio_scheduler_h
#include "kio/job.h"
#include "kio/jobclasses.h"
#include <tqtimer.h>
#include <tqptrdict.h>
#include <tqmap.h>
#include <dcopobject.h>
namespace KIO {
class Slave;
class SlaveList;
class SlaveConfig;
class SessionData;
/**
* The KIO::Scheduler manages io-slaves for the application.
* It also queues jobs and assigns the job to a slave when one
* becomes available.
*
* There are 3 possible ways for a job to get a slave:
*
* <h3>1. Direct</h3>
* This is the default. When you create a job the
* KIO::Scheduler will be notified and will find either an existing
* slave that is idle or it will create a new slave for the job.
*
* Example:
* \code
* TransferJob *job = KIO::get(KURL("http://www.kde.org"));
* \endcode
*
*
* <h3>2. Scheduled</h3>
* If you create a lot of jobs, you might want not want to have a
* slave for each job. If you schedule a job, a maximum number
* of slaves will be created. When more jobs arrive, they will be
* queued. When a slave is finished with a job, it will be assigned
* a job from the queue.
*
* Example:
* \code
* TransferJob *job = KIO::get(KURL("http://www.kde.org"));
* KIO::Scheduler::scheduleJob(job);
* \endcode
*
* <h3>3. Connection Oriented</h3>
* For some operations it is important that multiple jobs use
* the same connection. This can only be ensured if all these jobs
* use the same slave.
*
* You can ask the scheduler to open a slave for connection oriented
* operations. You can then use the scheduler to assign jobs to this
* slave. The jobs will be queued and the slave will handle these jobs
* one after the other.
*
* Example:
* \code
* Slave *slave = KIO::Scheduler::getConnectedSlave(
* KURL("pop3://bastian:password@mail.kde.org"));
* TransferJob *job1 = KIO::get(
* KURL("pop3://bastian:password@mail.kde.org/msg1"));
* KIO::Scheduler::assignJobToSlave(slave, job1);
* TransferJob *job2 = KIO::get(
* KURL("pop3://bastian:password@mail.kde.org/msg2"));
* KIO::Scheduler::assignJobToSlave(slave, job2);
* TransferJob *job3 = KIO::get(
* KURL("pop3://bastian:password@mail.kde.org/msg3"));
* KIO::Scheduler::assignJobToSlave(slave, job3);
*
* // ... Wait for jobs to finish...
*
* KIO::Scheduler::disconnectSlave(slave);
* \endcode
*
* Note that you need to explicitly disconnect the slave when the
* connection goes down, so your error handler should contain:
* \code
* if (error == KIO::ERR_CONNECTION_BROKEN)
* KIO::Scheduler::disconnectSlave(slave);
* \endcode
*
* @see KIO::Slave
* @see KIO::Job
**/
class KIO_EXPORT Scheduler : public TQObject, virtual public DCOPObject {
Q_OBJECT
public:
typedef TQPtrList<SimpleJob> JobList;
// InfoDict needs Info, so we can't declare it private
class ProtocolInfo;
class JobData;
~Scheduler();
/**
* Register @p job with the scheduler.
* The default is to create a new slave for the job if no slave
* is available. This can be changed by calling scheduleJob.
* @param job the job to register
*/
static void doJob(SimpleJob *job)
{ self()->_doJob(job); }
/**
* Calling ths function makes that @p job gets scheduled for later
* execution, if multiple jobs are registered it might wait for
* other jobs to finish.
* @param job the job to schedule
*/
static void scheduleJob(SimpleJob *job)
{ self()->_scheduleJob(job); }
/**
* Stop the execution of a job.
* @param job the job to cancel
*/
static void cancelJob(SimpleJob *job)
{ self()->_cancelJob(job); }
/**
* Called when a job is done.
* @param job the finished job
* @param slave the slave that executed the @p job
*/
static void jobFinished(KIO::SimpleJob *job, KIO::Slave *slave)
{ self()->_jobFinished(job, slave); }
/**
* Puts a slave on notice. A next job may reuse this slave if it
* requests the same URL.
*
* A job can be put on hold after it has emit'ed its mimetype.
* Based on the mimetype, the program can give control to another
* component in the same process which can then resume the job
* by simply asking for the same URL again.
* @param job the job that should be stopped
* @param url the URL that is handled by the @p url
*/
static void putSlaveOnHold(KIO::SimpleJob *job, const KURL &url)
{ self()->_putSlaveOnHold(job, url); }
/**
* Removes any slave that might have been put on hold. If a slave
* was put on hold it will be killed.
*/
static void removeSlaveOnHold()
{ self()->_removeSlaveOnHold(); }
/**
* Send the slave that was put on hold back to KLauncher. This
* allows another process to take over the slave and resume the job
* that was started.
*/
static void publishSlaveOnHold()
{ self()->_publishSlaveOnHold(); }
/**
* Requests a slave for use in connection-oriented mode.
*
* @param url This defines the username,password,host & port to
* connect with.
* @param config Configuration data for the slave.
*
* @return A pointer to a connected slave or 0 if an error occurred.
* @see assignJobToSlave()
* @see disconnectSlave()
*/
static KIO::Slave *getConnectedSlave(const KURL &url, const KIO::MetaData &config = MetaData() )
{ return self()->_getConnectedSlave(url, config); }
/*
* Uses @p slave to do @p job.
* This function should be called immediately after creating a Job.
*
* @param slave The slave to use. The slave must have been obtained
* with a call to getConnectedSlave and must not
* be currently assigned to any other job.
* @param job The job to do.
*
* @return true is successful, false otherwise.
*
* @see getConnectedSlave()
* @see disconnectSlave()
* @see slaveConnected()
* @see slaveError()
*/
static bool assignJobToSlave(KIO::Slave *slave, KIO::SimpleJob *job)
{ return self()->_assignJobToSlave(slave, job); }
/*
* Disconnects @p slave.
*
* @param slave The slave to disconnect. The slave must have been
* obtained with a call to getConnectedSlave
* and must not be assigned to any job.
*
* @return true is successful, false otherwise.
*
* @see getConnectedSlave
* @see assignJobToSlave
*/
static bool disconnectSlave(KIO::Slave *slave)
{ return self()->_disconnectSlave(slave); }
/**
* Send the slave that was put on hold back to KLauncher. This
* allows another process to take over the slave and resume the job
* the that was started.
* Register the mainwindow @p wid with the KIO subsystem
* Do not call this, it is called automatically from
* void KIO::Job::setWindow(TQWidget*).
* @param wid the window to register
* @since 3.1
*/
static void registerWindow(TQWidget *wid)
{ self()->_registerWindow(wid); }
/**
* @internal
* Unregisters the window registered by registerWindow().
*/
static void unregisterWindow(TQObject *wid)
{ self()->slotUnregisterWindow(wid); }
/**
* Function to connect signals emitted by the scheduler.
*
* @see slaveConnected()
* @see slaveError()
*/
static bool connect( const char *signal, const TQObject *receiver,
const char *member)
{ return TQObject::connect(self(), signal, receiver, member); }
static bool connect( const TQObject* sender, const char* signal,
const TQObject* receiver, const char* member )
{ return TQObject::connect(sender, signal, receiver, member); }
static bool disconnect( const TQObject* sender, const char* signal,
const TQObject* receiver, const char* member )
{ return TQObject::disconnect(sender, signal, receiver, member); }
bool connect( const TQObject *sender, const char *signal,
const char *member )
{ return TQObject::connect(sender, signal, member); }
/**
* When true, the next job will check whether KLauncher has a slave
* on hold that is suitable for the job.
* @param b true when KLauncher has a job on hold
*/
static void checkSlaveOnHold(bool b) { self()->_checkSlaveOnHold(b); }
void debug_info();
virtual bool process(const TQCString &fun, const TQByteArray &data,
TQCString& replyType, TQByteArray &replyData);
virtual QCStringList functions();
public slots:
void slotSlaveDied(KIO::Slave *slave);
void slotSlaveStatus(pid_t pid, const TQCString &protocol,
const TQString &host, bool connected);
signals:
void slaveConnected(KIO::Slave *slave);
void slaveError(KIO::Slave *slave, int error, const TQString &errorMsg);
protected:
void setupSlave(KIO::Slave *slave, const KURL &url, const TQString &protocol, const TQString &proxy , bool newSlave, const KIO::MetaData *config=0);
bool startJobScheduled(ProtocolInfo *protInfo);
bool startJobDirect();
Scheduler();
protected slots:
void startStep();
void slotCleanIdleSlaves();
void slotSlaveConnected();
void slotSlaveError(int error, const TQString &errorMsg);
void slotScheduleCoSlave();
/// @since 3.1
void slotUnregisterWindow(TQObject *);
private:
class ProtocolInfoDict;
class ExtraJobData;
Scheduler(const Scheduler&);
static Scheduler *self();
static Scheduler *instance;
void _doJob(SimpleJob *job);
void _scheduleJob(SimpleJob *job);
void _cancelJob(SimpleJob *job);
void _jobFinished(KIO::SimpleJob *job, KIO::Slave *slave);
void _scheduleCleanup();
void _putSlaveOnHold(KIO::SimpleJob *job, const KURL &url);
void _removeSlaveOnHold();
Slave *_getConnectedSlave(const KURL &url, const KIO::MetaData &metaData );
bool _assignJobToSlave(KIO::Slave *slave, KIO::SimpleJob *job);
bool _disconnectSlave(KIO::Slave *slave);
void _checkSlaveOnHold(bool b);
void _publishSlaveOnHold();
void _registerWindow(TQWidget *wid);
Slave *findIdleSlave(ProtocolInfo *protInfo, SimpleJob *job, bool &exact);
Slave *createSlave(ProtocolInfo *protInfo, SimpleJob *job, const KURL &url);
TQTimer slaveTimer;
TQTimer coSlaveTimer;
TQTimer cleanupTimer;
bool busy;
SlaveList *slaveList;
SlaveList *idleSlaves;
SlaveList *coIdleSlaves;
ProtocolInfoDict *protInfoDict;
Slave *slaveOnHold;
KURL urlOnHold;
JobList newJobs;
TQPtrDict<JobList> coSlaves;
ExtraJobData *extraJobData;
SlaveConfig *slaveConfig;
SessionData *sessionData;
bool checkOnHold;
TQMap<TQObject *,WId> m_windowList;
protected:
virtual void virtual_hook( int id, void* data );
private:
class SchedulerPrivate* d;
};
}
#endif