src/EventLoop.cc

   1 /*
   2  * $Id$
   3  *
   4  * DEBUG: section 01    Main Loop
   5  * AUTHOR: Harvest Derived
   6  *
   7  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   8  * ----------------------------------------------------------
   9  *
  10  *  Squid is the result of efforts by numerous individuals from
  11  *  the Internet community; see the CONTRIBUTORS file for full
  12  *  details.   Many organizations have provided support for Squid's
  13  *  development; see the SPONSORS file for full details.  Squid is
  14  *  Copyrighted (C) 2001 by the Regents of the University of
  15  *  California; see the COPYRIGHT file for full details.  Squid
  16  *  incorporates software developed and/or copyrighted by other
  17  *  sources; see the CREDITS file for full details.
  18  *
  19  *  This program is free software; you can redistribute it and/or modify
  20  *  it under the terms of the GNU General Public License as published by
  21  *  the Free Software Foundation; either version 2 of the License, or
  22  *  (at your option) any later version.
  23  *
  24  *  This program is distributed in the hope that it will be useful,
  25  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  *  GNU General Public License for more details.
  28  *
  29  *  You should have received a copy of the GNU General Public License
  30  *  along with this program; if not, write to the Free Software
  31  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  32  *
  33  */
  34
  35 #include "config.h"
  36 #include "EventLoop.h"
  37 #include "base/AsyncCallQueue.h"
  38
  39 EventLoop::EventLoop() : errcount(0), last_loop(false), timeService(NULL),
  40         primaryEngine(NULL)
  41 {}
  42
  43 void
  44 EventLoop::checkEngine(AsyncEngine * engine, bool const primary)
  45 {
  46     int requested_delay;
  47
  48     if (!primary)
  49         requested_delay = engine->checkEvents(0);
  50     else
  51         requested_delay = engine->checkEvents(loop_delay);
  52
  53     if (requested_delay < 0)
  54         switch (requested_delay) {
  55
  56         case AsyncEngine::EVENT_IDLE:
  57             debugs(1, 9, "Engine " << engine << " is idle.");
  58             break;
  59
  60         case AsyncEngine::EVENT_ERROR:
  61             runOnceResult = false;
  62             error = true;
  63             break;
  64
  65         default:
  66             fatal_dump("unknown AsyncEngine result");
  67         }
  68     else {
  69         /* not idle or error */
  70         runOnceResult = false;
  71
  72         if (requested_delay < loop_delay)
  73             loop_delay = requested_delay;
  74     }
  75 }
  76
  77 void
  78 EventLoop::prepareToRun()
  79 {
  80     last_loop = false;
  81     errcount = 0;
  82 }
  83
  84 void
  85 EventLoop::registerEngine(AsyncEngine *engine)
  86 {
  87     engines.push_back(engine);
  88 }
  89
  90 void
  91 EventLoop::run()
  92 {
  93     prepareToRun();
  94
  95     while (!runOnce());
  96 }
  97
  98 bool
  99 EventLoop::runOnce()
 100 {
 101     bool sawActivity = false;
 102     runOnceResult = true;
 103     error = false;
 104     loop_delay = EVENT_LOOP_TIMEOUT;
 105
 106     AsyncEngine *waitingEngine = primaryEngine;
 107     if (!waitingEngine && !engines.empty())
 108         waitingEngine = engines.back();
 109
 110     do {
 111         // generate calls and events
 112         typedef engine_vector::iterator EVI;
 113         for (EVI i = engines.begin(); i != engines.end(); ++i) {
 114             if (*i != waitingEngine)
 115                 checkEngine(*i, false);
 116         }
 117
 118         // dispatch calls accumulated so far
 119         sawActivity = dispatchCalls();
 120         if (sawActivity)
 121             runOnceResult = false;
 122     } while (sawActivity);
 123
 124     if (waitingEngine != NULL)
 125         checkEngine(waitingEngine, true);
 126
 127     if (timeService != NULL)
 128         timeService->tick();
 129
 130     // dispatch calls scheduled by waitingEngine and timeService
 131     sawActivity = dispatchCalls();
 132     if (sawActivity)
 133         runOnceResult = false;
 134
 135     if (error) {
 136         ++errcount;
 137         debugs(1, 0, "Select loop Error. Retry " << errcount);
 138     } else
 139         errcount = 0;
 140
 141     if (errcount == 10)
 142         return true;
 143
 144     if (last_loop)
 145         return true;
 146
 147     return runOnceResult;
 148 }
 149
 150 // dispatches calls accumulated during checkEngine()
 151 bool
 152 EventLoop::dispatchCalls()
 153 {
 154     bool dispatchedSome = AsyncCallQueue::Instance().fire();
 155     return dispatchedSome;
 156 }
 157
 158 void
 159 EventLoop::setPrimaryEngine(AsyncEngine * engine)
 160 {
 161     for (engine_vector::iterator i = engines.begin();
 162             i != engines.end(); ++i)
 163         if (*i == engine) {
 164             primaryEngine = engine;
 165             return;
 166         }
 167
 168     fatal("EventLoop::setPrimaryEngine: No such engine!.");
 169 }
 170
 171 void
 172 EventLoop::setTimeService(TimeEngine *engine)
 173 {
 174     timeService = engine;
 175 }
 176
 177 void
 178 EventLoop::stop()
 179 {
 180     last_loop = true;
 181 }