src/azdht/azdhtmodule.h

   1 /***************************************************************************
   2  *                                                                         *
   3  *   Copyright (C) 2007 David Brodsky                                      *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or         *
   6  *   modify it under the terms of the GNU General Public License as        *
   7  *   published by the Free Software Foundation and appearing               *
   8  *   in the file LICENSE.GPL included in the packaging of this file.       *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      *
  13  *   General Public License for more details.                              *
  14  *                                                                         *
  15  ***************************************************************************/
  16
  17 #ifndef _azdht_azdhtmodule_h
  18 #define _azdht_azdhtmodule_h
  19
  20 #include <map>
  21
  22 #include <tairon/core/module.h>
  23 #include <tairon/core/signals.h>
  24
  25 namespace Tairon
  26 {
  27
  28 namespace Net
  29 {
  30
  31 class Socket;
  32 class Timer;
  33
  34 }; // namespace Net
  35
  36 }; // namespace Tairon
  37
  38 namespace Tairent
  39 {
  40
  41 namespace Core
  42 {
  43
  44 class BEncode;
  45
  46 }; // namespace Core
  47
  48 namespace AzDHT
  49 {
  50
  51 /** \brief Module for communicating with AzDHT program.
  52  */
  53 class AzDHTModule : public Tairon::Core::Module
  54 {
  55         public:
  56                 enum Flags {
  57                         SINGLE_VALUE = 0,
  58                         DOWNLOADING = 1,
  59                         SEEDING = 2,
  60                         MULTI_VALUE = 4,
  61                         STATS = 8
  62                 };
  63
  64                 /** Constructs an AzDHTModule object.
  65                  */
  66                 AzDHTModule();
  67
  68                 /** Destroys the object.
  69                  */
  70                 virtual ~AzDHTModule();
  71
  72                 /** Queries the DHT for value.
  73                  */
  74                 void get(const String &key, char flags);
  75
  76                 /** Returns true if we are connected to the DHT; otherwise returns
  77                  * false.
  78                  */
  79                 bool isConnected();
  80
  81                 /** Puts new value in the DHT.
  82                  */
  83                 void put(const String &key, const String &value, char flags);
  84
  85                 /** Registers new handler for incoming values. If there is already
  86                  * associated handler for the given key then the old handler is
  87                  * deleted. This module takes ownership of the handler and all
  88                  * registered handlers are deleted when this module is unloaded.
  89                  *
  90                  * \param key Request's key.
  91                  * \param handler Functor that will be called when values arrive.
  92                  */
  93                 void registerHandler(const String &key, Tairon::Core::Functor2<void, const String &, const Tairent::Core::BEncode &> *handler);
  94
  95                 /** Removes value for given key from the DHT.
  96                  */
  97                 void remove(const String &key);
  98
  99                 /** Returns pointer to the instance of this class.
 100                  */
 101                 static AzDHTModule *self() {
 102                         return azdhtmodule;
 103                 };
 104
 105         private:
 106                 /** Called when we are connected to the AzDHT server.
 107                  */
 108                 void connected(Tairon::Net::Socket *);
 109
 110                 /** Closes the socket and tries to reconnect in 1 minute.
 111                  */
 112                 void connectionError();
 113
 114                 /** Ensures that the internal buffer is large enough.
 115                  *
 116                  * \param size Desired size of the buffer.
 117                  */
 118                 void enlargeBuffer(uint32_t size);
 119
 120                 /** Processes message incoming from the server.
 121                  *
 122                  * \param b Message sent by the server.
 123                  */
 124                 void processMessage(const Tairent::Core::BEncode &b);
 125
 126                 /** Reads body of the message.
 127                  */
 128                 void readMessage();
 129
 130                 /** Reads length of the message.
 131                  */
 132                 void readMessageLength();
 133
 134                 /** Called when there is something to read from the socket.
 135                  */
 136                 void readyRead(Tairon::Net::Socket *);
 137
 138                 /** Reconnects to the AzDHT program.
 139                  */
 140                 void reconnect();
 141
 142                 /** Sends query to the server.
 143                  */
 144                 void sendQuery(const Tairent::Core::BEncode &query);
 145
 146                 /** Called when an error occurs.
 147                  */
 148                 void socketError(Tairon::Net::Socket *, int);
 149
 150         private:
 151                 /** Address on which AzDHT is listening.
 152                  */
 153                 String address;
 154
 155                 /** Holds pointer to the instance of this class.
 156                  */
 157                 static AzDHTModule *azdhtmodule;
 158
 159                 /** Message buffer.
 160                  */
 161                 char *buffer;
 162
 163                 /** Size of the message buffer.
 164                  */
 165                 uint32_t bufSize;
 166
 167                 std::map<String, Tairon::Core::Functor2<void, const String &, const Tairent::Core::BEncode &> *> handlers;
 168
 169                 /** Method that reads data from the socket.
 170                  */
 171                 void (AzDHTModule::*readMethod)();
 172
 173                 /** Length of the message.
 174                  */
 175                 uint32_t msgLength;
 176
 177                 /** Number of bytes read so far.
 178                  */
 179                 uint32_t offset;
 180
 181                 /** Port on which AzDHT is listening.
 182                  */
 183                 uint16_t port;
 184
 185                 /** Connection with the AzDHT program.
 186                  */
 187                 Tairon::Net::Socket *socket;
 188
 189                 /** Timer for reconnecting to the AzDHT program.
 190                  */
 191                 Tairon::Net::Timer *timer;
 192 };
 193
 194 }; // namespace AzDHT
 195
 196 }; // namespace Tairent
 197
 198 #endif
 199
 200 // vim: ai sw=4 ts=4 noet fdm=marker