lib/base/ebase.cpp

   1 #include <lib/base/ebase.h>
   2
   3 #include <fcntl.h>
   4 #include <unistd.h>
   5 #include <errno.h>
   6
   7 #include <lib/base/eerror.h>
   8 #include <lib/base/elock.h>
   9
  10 eSocketNotifier::eSocketNotifier(eMainloop *context, int fd, int requested, bool startnow): context(*context), fd(fd), state(0), requested(requested)
  11 {
  12         if (startnow)
  13                 start();
  14 }
  15
  16 eSocketNotifier::~eSocketNotifier()
  17 {
  18         stop();
  19 }
  20
  21 void eSocketNotifier::start()
  22 {
  23         if (state)
  24                 stop();
  25
  26         context.addSocketNotifier(this);
  27         state=2;  // running but not in poll yet
  28 }
  29
  30 void eSocketNotifier::stop()
  31 {
  32         if (state)
  33                 context.removeSocketNotifier(this);
  34
  35         state=0;
  36 }
  37
  38                                         // timer
  39 void eTimer::start(long msek, bool singleShot)
  40 {
  41         if (bActive)
  42                 stop();
  43
  44         bActive = true;
  45         bSingleShot = singleShot;
  46         interval = msek;
  47         gettimeofday(&nextActivation, 0);
  48         nextActivation.tv_sec -= context.getTimeOffset();
  49 //      eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d msec", this, nextActivation.tv_sec, nextActivation.tv_usec, msek);
  50         nextActivation += (msek<0 ? 0 : msek);
  51 //      eDebug("next Activation sec = %d, usec = %d", nextActivation.tv_sec, nextActivation.tv_usec );
  52         context.addTimer(this);
  53 }
  54
  55 void eTimer::startLongTimer( int seconds )
  56 {
  57         if (bActive)
  58                 stop();
  59
  60         bActive = bSingleShot = true;
  61         interval = 0;
  62         gettimeofday(&nextActivation, 0);
  63         nextActivation.tv_sec -= context.getTimeOffset();
  64 //      eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d sec", this, nextActivation.tv_sec, nextActivation.tv_usec, seconds);
  65         if ( seconds > 0 )
  66                 nextActivation.tv_sec += seconds;
  67 //      eDebug("next Activation sec = %d, usec = %d", nextActivation.tv_sec, nextActivation.tv_usec );
  68         context.addTimer(this);
  69 }
  70
  71 void eTimer::stop()
  72 {
  73         if (bActive)
  74         {
  75                 bActive=false;
  76                 context.removeTimer(this);
  77         }
  78 }
  79
  80 void eTimer::changeInterval(long msek)
  81 {
  82         if (bActive)  // Timer is running?
  83         {
  84                 context.removeTimer(this);       // then stop
  85                 nextActivation -= interval;  // sub old interval
  86         }
  87         else
  88                 bActive=true; // then activate Timer
  89
  90         interval = msek;                                                // set new Interval
  91         nextActivation += interval;             // calc nextActivation
  92
  93         context.addTimer(this);                         // add Timer to context TimerList
  94 }
  95
  96 void eTimer::activate()   // Internal Funktion... called from eApplication
  97 {
  98         context.removeTimer(this);
  99
 100         if (!bSingleShot)
 101         {
 102                 nextActivation += interval;
 103                 context.addTimer(this);
 104         }
 105         else
 106                 bActive=false;
 107
 108         /*emit*/ timeout();
 109 }
 110
 111 void eTimer::addTimeOffset( int offset )
 112 {
 113         nextActivation.tv_sec += offset;
 114 }
 115
 116 // mainloop
 117 ePtrList<eMainloop> eMainloop::existing_loops;
 118
 119 void eMainloop::addSocketNotifier(eSocketNotifier *sn)
 120 {
 121         int fd = sn->getFD();
 122         ASSERT(notifiers.find(fd) == notifiers.end());
 123         notifiers[fd]=sn;
 124 }
 125
 126 void eMainloop::removeSocketNotifier(eSocketNotifier *sn)
 127 {
 128         int fd = sn->getFD();
 129         std::map<int,eSocketNotifier*>::iterator i(notifiers.find(fd));
 130         if (i != notifiers.end())
 131                 return notifiers.erase(i);
 132         eFatal("removed socket notifier which is not present");
 133 }
 134
 135 int eMainloop::processOneEvent(unsigned int twisted_timeout, PyObject **res, ePyObject additional)
 136 {
 137         int return_reason = 0;
 138                 /* get current time */
 139
 140         if (additional && !PyDict_Check(additional))
 141                 eFatal("additional, but it's not dict");
 142
 143         if (additional && !res)
 144                 eFatal("additional, but no res");
 145
 146         long poll_timeout = -1; /* infinite in case of empty timer list */
 147
 148         if (!m_timer_list.empty() || twisted_timeout > 0)
 149         {
 150                 applyTimeOffset();
 151                 if (!m_timer_list.empty())
 152                 {
 153                         /* process all timers which are ready. first remove them out of the list. */
 154                         while (!m_timer_list.empty() && (poll_timeout = timeout_usec( m_timer_list.begin()->getNextActivation() ) ) <= 0 )
 155                         {
 156                                 m_timer_list.begin()->activate();
 157                                 applyTimeOffset();
 158                         }
 159                         if (poll_timeout < 0)
 160                                 poll_timeout = 0;
 161                         else /* convert us to ms */
 162                                 poll_timeout /= 1000;
 163                 }
 164         }
 165
 166         if ((twisted_timeout > 0) && (poll_timeout > 0) && ((unsigned int)poll_timeout > twisted_timeout))
 167         {
 168                 poll_timeout = twisted_timeout;
 169                 return_reason = 1;
 170         }
 171
 172         int nativecount=notifiers.size(),
 173                 fdcount=nativecount,
 174                 ret=0;
 175
 176         if (additional)
 177                 fdcount += PyDict_Size(additional);
 178
 179                 // build the poll aray
 180         pollfd pfd[fdcount];  // make new pollfd array
 181         std::map<int,eSocketNotifier*>::iterator it = notifiers.begin();
 182         int i=0;
 183         for (; i < nativecount; ++i, ++it)
 184         {
 185                 it->second->state = 1; // running and in poll
 186                 pfd[i].fd = it->first;
 187                 pfd[i].events = it->second->getRequested();
 188         }
 189
 190         if (additional)
 191         {
 192                 PyObject *key, *val;
 193                 int pos=0;
 194                 while (PyDict_Next(additional, &pos, &key, &val)) {
 195                         pfd[i].fd = PyObject_AsFileDescriptor(key);
 196                         pfd[i++].events = PyInt_AsLong(val);
 197                 }
 198         }
 199
 200         m_is_idle = 1;
 201
 202         if (this == eApp)
 203         {
 204                 Py_BEGIN_ALLOW_THREADS
 205                 ret = ::poll(pfd, fdcount, poll_timeout);
 206                 Py_END_ALLOW_THREADS
 207         } else
 208                 ret = ::poll(pfd, fdcount, poll_timeout);
 209
 210         m_is_idle = 0;
 211
 212                         /* ret > 0 means that there are some active poll entries. */
 213         if (ret > 0)
 214         {
 215                 int i=0;
 216                 return_reason = 0;
 217                 for (; i < nativecount; ++i)
 218                 {
 219                         if (pfd[i].revents)
 220                         {
 221                                 it = notifiers.find(pfd[i].fd);
 222                                 if (it != notifiers.end()
 223                                         && it->second->state == 1) // added and in poll
 224                                 {
 225                                         int req = it->second->getRequested();
 226                                         if (pfd[i].revents & req)
 227                                                 it->second->activate(pfd[i].revents & req);
 228                                         pfd[i].revents &= ~req;
 229                                 }
 230                                 if (pfd[i].revents & (POLLERR|POLLHUP|POLLNVAL))
 231                                         eDebug("poll: unhandled POLLERR/HUP/NVAL for fd %d(%d)", pfd[i].fd, pfd[i].revents);
 232                         }
 233                 }
 234                 for (; i < fdcount; ++i)
 235                 {
 236                         if (pfd[i].revents)
 237                         {
 238                                 if (!*res)
 239                                         *res = PyList_New(0);
 240                                 ePyObject it = PyTuple_New(2);
 241                                 PyTuple_SET_ITEM(it, 0, PyInt_FromLong(pfd[i].fd));
 242                                 PyTuple_SET_ITEM(it, 1, PyInt_FromLong(pfd[i].revents));
 243                                 PyList_Append(*res, it);
 244                                 Py_DECREF(it);
 245                         }
 246                 }
 247         }
 248         else if (ret < 0)
 249         {
 250                         /* when we got a signal, we get EINTR. */
 251                 if (errno != EINTR)
 252                         eDebug("poll made error (%m)");
 253                 else
 254                         return_reason = 2; /* don't assume the timeout has passed when we got a signal */
 255         }
 256
 257         return return_reason;
 258 }
 259
 260 void eMainloop::addTimer(eTimer* e)
 261 {
 262         m_timer_list.insert_in_order(e);
 263 }
 264
 265 void eMainloop::removeTimer(eTimer* e)
 266 {
 267         m_timer_list.remove(e);
 268 }
 269
 270 int eMainloop::iterate(unsigned int twisted_timeout, PyObject **res, ePyObject dict)
 271 {
 272         int ret = 0;
 273
 274         if (twisted_timeout)
 275         {
 276                 gettimeofday(&m_twisted_timer, 0);
 277                 m_twisted_timer += twisted_timeout;
 278         }
 279
 280                 /* TODO: this code just became ugly. fix that. */
 281         do
 282         {
 283                 if (m_interrupt_requested)
 284                 {
 285                         m_interrupt_requested = 0;
 286                         return 0;
 287                 }
 288
 289                 if (app_quit_now)
 290                         return -1;
 291
 292                 int to = 0;
 293                 if (twisted_timeout)
 294                 {
 295                         timeval now, timeout;
 296                         gettimeofday(&now, 0);
 297                         m_twisted_timer += time_offset;  // apply pending offset
 298                         if (m_twisted_timer<=now) // timeout
 299                                 return 0;
 300                         timeout = m_twisted_timer - now;
 301                         to = timeout.tv_sec * 1000 + timeout.tv_usec / 1000;
 302                         // remove pending offset .. it is re-applied in next call of processOneEvent.. applyTimeOffset
 303                         m_twisted_timer -= time_offset;
 304                 }
 305                 ret = processOneEvent(to, res, dict);
 306         } while ( !ret && !(res && *res) );
 307
 308         return ret;
 309 }
 310
 311 int eMainloop::runLoop()
 312 {
 313         while (!app_quit_now)
 314                 iterate();
 315         return retval;
 316 }
 317
 318 void eMainloop::reset()
 319 {
 320         app_quit_now=false;
 321 }
 322
 323 PyObject *eMainloop::poll(ePyObject timeout, ePyObject dict)
 324 {
 325         PyObject *res=0;
 326
 327         if (app_quit_now)
 328                 Py_RETURN_NONE;
 329
 330         int twisted_timeout = (timeout == Py_None) ? 0 : PyInt_AsLong(timeout);
 331
 332         iterate(twisted_timeout, &res, dict);
 333         if (res)
 334                 return res;
 335
 336         return PyList_New(0); /* return empty list on timeout */
 337 }
 338
 339 void eMainloop::interruptPoll()
 340 {
 341         m_interrupt_requested = 1;
 342 }
 343
 344 void eMainloop::quit(int ret)
 345 {
 346         retval = ret;
 347         app_quit_now = true;
 348 }
 349
 350 void eMainloop::addTimeOffset(int offset)
 351 {
 352         for (ePtrList<eMainloop>::iterator it(existing_loops.begin()); it != existing_loops.end(); ++it )
 353                 it->addInstanceTimeOffset(offset);
 354 }
 355
 356 void eMainloop::addInstanceTimeOffset(int offset)
 357 {
 358         singleLock s(recalcLock);
 359         if (m_timer_list.empty())
 360                 time_offset=0;
 361         else
 362         {
 363                 if ( time_offset )
 364                         eDebug("time_offset %d avail.. add new offset %d than new is %d",
 365                         time_offset, offset, time_offset+offset);
 366                 time_offset+=offset;
 367         }
 368 }
 369
 370 void eMainloop::applyTimeOffset()
 371 {
 372         singleLock s(recalcLock);
 373         if ( time_offset )
 374         {
 375                 for (ePtrList<eTimer>::iterator it(m_timer_list.begin()); it != m_timer_list.end(); ++it )
 376                         it->addTimeOffset( time_offset );
 377                 m_twisted_timer += time_offset;
 378                 time_offset=0;
 379         }
 380 }
 381
 382 eApplication* eApp = 0;