src/ThreadTasks.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2006-2011 Mikkel Schubert ( xaignar@amule.org / http:://www.amule.org )
   5 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
   6 // Copyright (c) 2002-2011 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 private:
 115         void SetHashingProgress(uint16 part);
 116 };
 117
 118
 119 /**
 120  * This task synchronizes the AICH hashlist.
 121  *
 122  * Shared files that are lacking a AICH-hash are scheduled for hashing.
 123  */
 124 class CAICHSyncTask : public CThreadTask
 125 {
 126 public:
 127         CAICHSyncTask();
 128
 129 protected:
 130         /** See CThreadTask::Entry */
 131         virtual void Entry();
 132
 133         /** Converts old known2.met files to known2_64.met files. */
 134         bool ConvertToKnown2ToKnown264();
 135 };
 136
 137
 138 /**
 139  * This task performs the final tasks on a complete download.
 140  *
 141  * This includes finding a usable destination filename, removing
 142  * old data files and moving the part-file (potentially to a
 143  * different partition).
 144  **/
 145 class CCompletionTask : public CThreadTask
 146 {
 147 public:
 148         /**
 149          * Creates a thread which will complete the given download.
 150          */
 151         CCompletionTask(const CPartFile* file);
 152
 153 protected:
 154         /** See CThreadTask::Entry */
 155         virtual void Entry();
 156
 157         /** See CThreadTask::OnExit */
 158         virtual void OnExit();
 159
 160         //! The target filename.
 161         CPath           m_filename;
 162         //! The full path to the .met-file
 163         CPath           m_metPath;
 164         //! The category of the download.
 165         uint8           m_category;
 166         //! Owner of the file, used when sending completion-event.
 167         const CPartFile*        m_owner;
 168         //! Specifies if an error occured during completion.
 169         bool            m_error;
 170         //! The resulting full path. File may be be renamed.
 171         CPath           m_newName;
 172 };
 173
 174
 175 /**
 176  * This task preallocates space for a newly created partfile.
 177  */
 178 class CAllocateFileTask : public CThreadTask
 179 {
 180       public:
 181         /** Creates a thread that will allocate disk space for the full file. */
 182         CAllocateFileTask(CPartFile *file, bool pause);
 183
 184       protected:
 185         /** See CThreadTask::Entry */
 186         virtual void Entry();
 187
 188         /** See CThreadTask::OnExit */
 189         virtual void OnExit();
 190
 191       private:
 192         //! The partfile for which this task allocates space.
 193         CPartFile *     m_file;
 194
 195         //! Should this download start paused?
 196         bool            m_pause;
 197
 198         //! Result of the preallocation.
 199         long            m_result;
 200 };
 201
 202
 203 /**
 204  * This event is used to signal the completion of a hashing event.
 205  *
 206  * @see CHashingTask
 207  */
 208 class CHashingEvent : public wxEvent
 209 {
 210 public:
 211         /**
 212          * @param type MULE_EVT_HASHING or MULE_EVT_AICH_HASHING.
 213          * @param result
 214          */
 215         CHashingEvent(wxEventType type, CKnownFile* result, const CKnownFile* owner = NULL);
 216
 217         /** @see wxEvent::Clone */
 218         virtual wxEvent* Clone() const;
 219
 220         /** Returns the owner (may be NULL) of the hashing result. */
 221         const CKnownFile* GetOwner() const;
 222         /** Returns a CKnownfile used to store the results of the hashing. */
 223         CKnownFile* GetResult() const;
 224
 225 private:
 226         //! The file owner.
 227         const CKnownFile* m_owner;
 228         //! The hashing results.
 229         CKnownFile* m_result;
 230 };
 231
 232
 233 /**
 234  * This event is sent when a part-file has been completed.
 235  */
 236 class CCompletionEvent : public wxEvent
 237 {
 238 public:
 239         /** Constructor, see getter funtion for description of parameters. */
 240         CCompletionEvent(bool errorOccured, const CPartFile* owner, const CPath& fullPath);
 241
 242         /** @see wxEvent::Clone */
 243         virtual wxEvent* Clone() const;
 244
 245         /** Returns true if completion failed. */
 246         bool ErrorOccured() const;
 247
 248         /** Returns the owner of the file that was being completed. */
 249         const CPartFile* GetOwner() const;
 250
 251         /** Returns the full path to the completed file (empty on failure). */
 252         const CPath& GetFullPath() const;
 253 private:
 254         //! The full path to the completed file.
 255         CPath m_fullPath;
 256
 257         //! The owner of the completed .part file.
 258         const CPartFile* m_owner;
 259
 260         //! Specifies if completion failed.
 261         bool m_error;
 262 };
 263
 264
 265 /**
 266  * This event is sent when preallocation of a new partfile is finished.
 267  */
 268 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_ALLOC_FINISHED, -1);
 269 class CAllocFinishedEvent : public wxEvent
 270 {
 271       public:
 272         /** Constructor, see getter function for description of parameters. */
 273         CAllocFinishedEvent(CPartFile *file, bool pause, long result)
 274                 : wxEvent(-1, MULE_EVT_ALLOC_FINISHED),
 275                   m_file(file), m_pause(pause), m_result(result)
 276         {}
 277
 278         /** @see wxEvent::Clone */
 279         virtual wxEvent *Clone() const;
 280
 281         /** Returns the partfile for which preallocation was requested. */
 282         CPartFile *GetFile() const throw()      { return m_file; }
 283
 284         /** Returns whether the partfile should start paused. */
 285         bool    IsPaused() const throw()        { return m_pause; }
 286
 287         /** Returns the result of preallocation: true on success, false otherwise. */
 288         bool    Succeeded() const throw()       { return m_result == 0; }
 289
 290         /** Returns the result of the preallocation. */
 291         long    GetResult() const throw()       { return m_result; }
 292
 293       private:
 294         //! The partfile for which preallocation was requested.
 295         CPartFile *     m_file;
 296
 297         //! Should the download start paused?
 298         bool            m_pause;
 299
 300         //! Result of preallocation
 301         long            m_result;
 302 };
 303
 304 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_HASHING, -1)
 305 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_AICH_HASHING, -1)
 306 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_FILE_COMPLETED, -1)
 307
 308
 309 typedef void (wxEvtHandler::*MuleHashingEventFunction)(CHashingEvent&);
 310 typedef void (wxEvtHandler::*MuleCompletionEventFunction)(CCompletionEvent&);
 311 typedef void (wxEvtHandler::*MuleAllocFinishedEventFunction)(CAllocFinishedEvent&);
 312
 313 //! Event-handler for completed hashings of new shared files and partfiles.
 314 #define EVT_MULE_HASHING(func) \
 315         DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_HASHING, -1, -1, \
 316         (wxObjectEventFunction) (wxEventFunction) \
 317         wxStaticCastEvent(MuleHashingEventFunction, &func), (wxObject*) NULL),
 318
 319 //! Event-handler for completed hashings of files that were missing a AICH hash.
 320 #define EVT_MULE_AICH_HASHING(func) \
 321         DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_AICH_HASHING, -1, -1, \
 322         (wxObjectEventFunction) (wxEventFunction) \
 323         wxStaticCastEvent(MuleHashingEventFunction, &func), (wxObject*) NULL),
 324
 325 //! Event-handler for completion of part-files.
 326 #define EVT_MULE_FILE_COMPLETED(func) \
 327         DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_FILE_COMPLETED, -1, -1, \
 328         (wxObjectEventFunction) (wxEventFunction) \
 329         wxStaticCastEvent(MuleCompletionEventFunction, &func), (wxObject*) NULL),
 330
 331 //! Event-handler for partfile preallocation finished events.
 332 #define EVT_MULE_ALLOC_FINISHED(func) \
 333         DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_ALLOC_FINISHED, -1, -1, \
 334         (wxObjectEventFunction) (wxEventFunction) \
 335         wxStaticCastEvent(MuleAllocFinishedEventFunction, &func), (wxObject*) NULL),
 336
 337
 338 #endif // TASKS_H
 339 // File_checked_for_headers