src/ThreadTasks.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2006-2008 Mikkel Schubert ( xaignar@amule.org / http:://www.amule.org )
   5 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   6 // Copyright (c) 2002-2008 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   7 //
   8 // Any parts of this program derived from the xMule, lMule or eMule project,
   9 // or contributed by third-party developers are copyrighted by their
  10 // respective authors.
  11 //
  12 // This program is free software; you can redistribute it and/or modify
  13 // it under the terms of the GNU General Public License as published by
  14 // the Free Software Foundation; either version 2 of the License, or
  15 // (at your option) any later version.
  16 //
  17 // This program is distributed in the hope that it will be useful,
  18 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 // GNU General Public License for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License
  23 // along with this program; if not, write to the Free Software
  24 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  25 //
  26
  27 #ifndef TASKS_H
  28 #define TASKS_H
  29
  30 #include "ThreadScheduler.h"
  31 #include <common/Path.h>
  32
  33 class CKnownFile;
  34 class CPartFile;
  35 class CFileAutoClose;
  36
  37
  38 /**
  39  * This task performs MD4 and/or AICH hashings of a file,
  40  * depending on the type. For new shared files (using the
  41  * first constructor, with part == NULL), both MD4 and
  42  * AICH hashes are created. For incomplete partfiles
  43  * (rehashed due to changed timestamps), only MD4 hashing
  44  * is done. For complete partfiles, both MD4 and AICH
  45  * hashing is done.
  46  *
  47  * For existing shared files (using the second constructor),
  48  * only an AICH hash is created.
  49  *
  50  * @see CHashingEvent
  51  * @see CAICHSyncTask
  52  */
  53 class CHashingTask : public CThreadTask
  54 {
  55 public:
  56         /**
  57          * Schedules a partfile or new shared file for hashing.
  58          *
  59          * @param path The full path, without filename.
  60          * @param filename The actual filename.
  61          * @param part Used to identify the owner in the event-handler (PartFiles only).
  62          *
  63          * CHashingEvents sent by this type of tasks have the id MULE_EVT_HASHING.
  64          * @see EVT_MULE_HASHING
  65          */
  66         CHashingTask(const CPath& path, const CPath& filename, const CPartFile* part = NULL);
  67
  68         /**
  69          * Schedules a KnownFile to have a AICH hashset created, used by CAICHSyncTask.
  70          *
  71          * CHashingEvents sent by this type of tasks have the id MULE_EVT_AICH_HASHING.
  72          * @see EVT_MULE_AICH_HASHING
  73          **/
  74         CHashingTask(const CKnownFile* toAICHHash);
  75
  76 protected:
  77         //! Specifies which hashes should be calculated when the task is executed.
  78         enum EHashes {
  79                 EH_AICH = 1,
  80                 EH_MD4 = 2
  81         };
  82
  83         //! @see CThreadTask::OnLastTask
  84         virtual void OnLastTask();
  85
  86         //! @see CThreadTask::Entry
  87         virtual void Entry();
  88
  89         /**
  90          * Helper function for hashing a PARTSIZE chunk of a file.
  91          *
  92          * @param file The file to read from.
  93          * @param part The number of the part to hash.
  94          * @param owner The known- (or part) file representing that file.
  95          * @bool createAICH Specifies if AICH hash-sets should be created as well.
  96          * @return Returns false on read-errors, true otherwise.
  97          *
  98          * This function will create a MD4 hash and, if specified, a AICH hashset for
  99          * the next part of the file. This function makes the assumption that it wont
 100          * be called for closed or EOF files.
 101          */
 102         bool CreateNextPartHash(CFileAutoClose& file, uint16 part, CKnownFile* owner, EHashes toHash);
 103
 104
 105         //! The path to the file to be hashed (shared or part), without filename.
 106         CPath m_path;
 107         //! The filename of the file to be hashed (filename only).
 108         CPath m_filename;
 109         //! Specifies which hash-types should be calculated
 110         EHashes m_toHash;
 111         //! If a partfile or an AICH hashing, this pointer stores it for callbacks.
 112         const CKnownFile* m_owner;
 113 };
 114
 115
 116 /**
 117  * This task synchronizes the AICH hashlist.
 118  *
 119  * Shared files that are lacking a AICH-hash are scheduled for hashing.
 120  */
 121 class CAICHSyncTask : public CThreadTask
 122 {
 123 public:
 124         CAICHSyncTask();
 125
 126 protected:
 127         /** See CThreadTask::Entry */
 128         virtual void Entry();
 129
 130         /** Converts old known2.met files to known2_64.met files. */
 131         bool ConvertToKnown2ToKnown264();
 132 };
 133
 134
 135 /**
 136  * This task performs the final tasks on a complete download.
 137  *
 138  * This includes finding a usable destination filename, removing
 139  * old data files and moving the part-file (potentially to a
 140  * different partition).
 141  **/
 142 class CCompletionTask : public CThreadTask
 143 {
 144 public:
 145         /**
 146          * Creates a thread which will complete the given download.
 147          */
 148         CCompletionTask(const CPartFile* file);
 149
 150 protected:
 151         /** See CThreadTask::Entry */
 152         virtual void Entry();
 153
 154         /** See CThreadTask::OnExit */
 155         virtual void OnExit();
 156
 157         //! The target filename.
 158         CPath           m_filename;
 159         //! The full path to the .met-file
 160         CPath           m_metPath;
 161         //! The category of the download.
 162         uint8           m_category;
 163         //! Owner of the file, used when sending completion-event.
 164         const CPartFile*        m_owner;
 165         //! Specifies if an error occured during completion.
 166         bool            m_error;
 167         //! The resulting full path. File may be be renamed.
 168         CPath           m_newName;
 169 };
 170
 171
 172 /**
 173  * This task preallocates space for a newly created partfile.
 174  */
 175 class CAllocateFileTask : public CThreadTask
 176 {
 177       public:
 178         /** Creates a thread that will allocate disk space for the full file. */
 179         CAllocateFileTask(CPartFile *file, bool pause);
 180
 181       protected:
 182         /** See CThreadTask::Entry */
 183         virtual void Entry();
 184
 185         /** See CThreadTask::OnExit */
 186         virtual void OnExit();
 187
 188       private:
 189         //! The partfile for which this task allocates space.
 190         CPartFile *     m_file;
 191
 192         //! Should this download start paused?
 193         bool            m_pause;
 194
 195         //! Result of the preallocation.
 196         long            m_result;
 197 };
 198
 199
 200 /**
 201  * This event is used to signal the completion of a hashing event.
 202  *
 203  * @see CHashingTask
 204  */
 205 class CHashingEvent : public wxEvent
 206 {
 207 public:
 208         /**
 209          * @param type MULE_EVT_HASHING or MULE_EVT_AICH_HASHING.
 210          * @param result
 211          */
 212         CHashingEvent(wxEventType type, CKnownFile* result, const CKnownFile* owner = NULL);
 213
 214         /** @see wxEvent::Clone */
 215         virtual wxEvent* Clone() const;
 216
 217         /** Returns the owner (may be NULL) of the hashing result. */
 218         const CKnownFile* GetOwner() const;
 219         /** Returns a CKnownfile used to store the results of the hashing. */
 220         CKnownFile* GetResult() const;
 221
 222 private:
 223         //! The file owner.
 224         const CKnownFile* m_owner;
 225         //! The hashing results.
 226         CKnownFile* m_result;
 227 };
 228
 229
 230 /**
 231  * This event is sent when a part-file has been completed.
 232  */
 233 class CCompletionEvent : public wxEvent
 234 {
 235 public:
 236         /** Constructor, see getter funtion for description of parameters. */
 237         CCompletionEvent(bool errorOccured, const CPartFile* owner, const CPath& fullPath);
 238
 239         /** @see wxEvent::Clone */
 240         virtual wxEvent* Clone() const;
 241
 242         /** Returns true if completion failed. */
 243         bool ErrorOccured() const;
 244
 245         /** Returns the owner of the file that was being completed. */
 246         const CPartFile* GetOwner() const;
 247
 248         /** Returns the full path to the completed file (empty on failure). */
 249         const CPath& GetFullPath() const;
 250 private:
 251         //! The full path to the completed file.
 252         CPath m_fullPath;
 253
 254         //! The owner of the completed .part file.
 255         const CPartFile* m_owner;
 256
 257         //! Specifies if completion failed.
 258         bool m_error;
 259 };
 260
 261
 262 /**
 263  * This event is sent when preallocation of a new partfile is finished.
 264  */
 265 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_ALLOC_FINISHED, -1);
 266 class CAllocFinishedEvent : public wxEvent
 267 {
 268       public:
 269         /** Constructor, see getter function for description of parameters. */
 270         CAllocFinishedEvent(CPartFile *file, bool pause, long result)
 271                 : wxEvent(-1, MULE_EVT_ALLOC_FINISHED),
 272                   m_file(file), m_pause(pause), m_result(result)
 273         {}
 274
 275         /** @see wxEvent::Clone */
 276         virtual wxEvent *Clone() const;
 277
 278         /** Returns the partfile for which preallocation was requested. */
 279         CPartFile *GetFile() const throw()      { return m_file; }
 280
 281         /** Returns whether the partfile should start paused. */
 282         bool    IsPaused() const throw()        { return m_pause; }
 283
 284         /** Returns the result of preallocation: true on success, false otherwise. */
 285         bool    Succeeded() const throw()       { return m_result == 0; }
 286
 287         /** Returns the result of the preallocation. */
 288         long    GetResult() const throw()       { return m_result; }
 289
 290       private:
 291         //! The partfile for which preallocation was requested.
 292         CPartFile *     m_file;
 293
 294         //! Should the download start paused?
 295         bool            m_pause;
 296
 297         //! Result of preallocation
 298         long            m_result;
 299 };
 300
 301 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_HASHING, -1)
 302 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_AICH_HASHING, -1)
 303 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_FILE_COMPLETED, -1)
 304
 305
 306 typedef void (wxEvtHandler::*MuleHashingEventFunction)(CHashingEvent&);
 307 typedef void (wxEvtHandler::*MuleCompletionEventFunction)(CCompletionEvent&);
 308 typedef void (wxEvtHandler::*MuleAllocFinishedEventFunction)(CAllocFinishedEvent&);
 309
 310 //! Event-handler for completed hashings of new shared files and partfiles.
 311 #define EVT_MULE_HASHING(func) \
 312         DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_HASHING, -1, -1, \
 313         (wxObjectEventFunction) (wxEventFunction) \
 314         wxStaticCastEvent(MuleHashingEventFunction, &func), (wxObject*) NULL),
 315
 316 //! Event-handler for completed hashings of files that were missing a AICH hash.
 317 #define EVT_MULE_AICH_HASHING(func) \
 318         DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_AICH_HASHING, -1, -1, \
 319         (wxObjectEventFunction) (wxEventFunction) \
 320         wxStaticCastEvent(MuleHashingEventFunction, &func), (wxObject*) NULL),
 321
 322 //! Event-handler for completion of part-files.
 323 #define EVT_MULE_FILE_COMPLETED(func) \
 324         DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_FILE_COMPLETED, -1, -1, \
 325         (wxObjectEventFunction) (wxEventFunction) \
 326         wxStaticCastEvent(MuleCompletionEventFunction, &func), (wxObject*) NULL),
 327
 328 //! Event-handler for partfile preallocation finished events.
 329 #define EVT_MULE_ALLOC_FINISHED(func) \
 330         DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_ALLOC_FINISHED, -1, -1, \
 331         (wxObjectEventFunction) (wxEventFunction) \
 332         wxStaticCastEvent(MuleAllocFinishedEventFunction, &func), (wxObject*) NULL),
 333
 334
 335 #endif // TASKS_H
 336 // File_checked_for_headers