]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - lib/iomaster.php
Merge branch 'testing' of gitorious.org:statusnet/mainline
[quix0rs-gnu-social.git] / lib / iomaster.php
1 <?php
2 /**
3  * StatusNet, the distributed open-source microblogging tool
4  *
5  * I/O manager to wrap around socket-reading and polling queue & connection managers.
6  *
7  * PHP version 5
8  *
9  * LICENCE: This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU Affero General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU Affero General Public License for more details.
18  *
19  * You should have received a copy of the GNU Affero General Public License
20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  *
22  * @category  QueueManager
23  * @package   StatusNet
24  * @author    Brion Vibber <brion@status.net>
25  * @copyright 2009 StatusNet, Inc.
26  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html GNU Affero General Public License version 3.0
27  * @link      http://status.net/
28  */
29
30 abstract class IoMaster
31 {
32     public $id;
33
34     protected $multiSite = false;
35     protected $managers = array();
36     protected $singletons = array();
37
38     protected $pollTimeouts = array();
39     protected $lastPoll = array();
40
41     public $shutdown = false; // Did we do a graceful shutdown?
42     public $respawn = true; // Should we respawn after shutdown?
43
44     /**
45      * @param string $id process ID to use in logging/monitoring
46      */
47     public function __construct($id)
48     {
49         $this->id = $id;
50         $this->monitor = new QueueMonitor();
51     }
52
53     public function init($multiSite=null)
54     {
55         if ($multiSite !== null) {
56             $this->multiSite = $multiSite;
57         }
58         if ($this->multiSite) {
59             $this->sites = $this->findAllSites();
60         } else {
61             $this->sites = array(common_config('site', 'server'));
62         }
63
64         if (empty($this->sites)) {
65             throw new Exception("Empty status_network table, cannot init");
66         }
67
68         foreach ($this->sites as $site) {
69             if ($site != common_config('site', 'server')) {
70                 StatusNet::init($site);
71             }
72             $this->initManagers();
73         }
74     }
75
76     /**
77      * Initialize IoManagers for the currently configured site
78      * which are appropriate to this instance.
79      *
80      * Pass class names into $this->instantiate()
81      */
82     abstract function initManagers();
83
84     /**
85      * Pull all local sites from status_network table.
86      * @return array of hostnames
87      */
88     protected function findAllSites()
89     {
90         $hosts = array();
91         $sn = new Status_network();
92         $sn->find();
93         while ($sn->fetch()) {
94             $hosts[] = $sn->getServerName();
95         }
96         return $hosts;
97     }
98
99     /**
100      * Instantiate an i/o manager class for the current site.
101      * If a multi-site capable handler is already present,
102      * we don't need to build a new one.
103      *
104      * @param string $class
105      */
106     protected function instantiate($class)
107     {
108         if (isset($this->singletons[$class])) {
109             // Already instantiated a multi-site-capable handler.
110             // Just let it know it should listen to this site too!
111             $this->singletons[$class]->addSite(common_config('site', 'server'));
112             return;
113         }
114
115         $manager = $this->getManager($class);
116
117         if ($this->multiSite) {
118             $caps = $manager->multiSite();
119             if ($caps == IoManager::SINGLE_ONLY) {
120                 throw new Exception("$class can't run with --all; aborting.");
121             }
122             if ($caps == IoManager::INSTANCE_PER_PROCESS) {
123                 // Save this guy for later!
124                 // We'll only need the one to cover multiple sites.
125                 $this->singletons[$class] = $manager;
126                 $manager->addSite(common_config('site', 'server'));
127             }
128         }
129
130         $this->managers[] = $manager;
131     }
132     
133     protected function getManager($class)
134     {
135         return call_user_func(array($class, 'get'));
136     }
137
138     /**
139      * Basic run loop...
140      *
141      * Initialize all io managers, then sit around waiting for input.
142      * Between events or timeouts, pass control back to idle() method
143      * to allow for any additional background processing.
144      */
145     function service()
146     {
147         $this->logState('init');
148         $this->start();
149
150         while (!$this->shutdown) {
151             $timeouts = array_values($this->pollTimeouts);
152             $timeouts[] = 60; // default max timeout
153
154             // Wait for something on one of our sockets
155             $sockets = array();
156             $managers = array();
157             foreach ($this->managers as $manager) {
158                 foreach ($manager->getSockets() as $socket) {
159                     $sockets[] = $socket;
160                     $managers[] = $manager;
161                 }
162                 $timeouts[] = intval($manager->timeout());
163             }
164
165             $timeout = min($timeouts);
166             if ($sockets) {
167                 $read = $sockets;
168                 $write = array();
169                 $except = array();
170                 $this->logState('listening');
171                 common_log(LOG_DEBUG, "Waiting up to $timeout seconds for socket data...");
172                 $ready = stream_select($read, $write, $except, $timeout, 0);
173
174                 if ($ready === false) {
175                     common_log(LOG_ERR, "Error selecting on sockets");
176                 } else if ($ready > 0) {
177                     foreach ($read as $socket) {
178                         $index = array_search($socket, $sockets, true);
179                         if ($index !== false) {
180                             $this->logState('queue');
181                             $managers[$index]->handleInput($socket);
182                         } else {
183                             common_log(LOG_ERR, "Saw input on a socket we didn't listen to");
184                         }
185                     }
186                 }
187             }
188
189             if ($timeout > 0 && empty($sockets)) {
190                 // If we had no listeners, sleep until the pollers' next requested wakeup.
191                 common_log(LOG_DEBUG, "Sleeping $timeout seconds until next poll cycle...");
192                 $this->logState('sleep');
193                 sleep($timeout);
194             }
195
196             $this->logState('poll');
197             $this->poll();
198
199             $this->logState('idle');
200             $this->idle();
201
202             $this->checkMemory();
203         }
204
205         $this->logState('shutdown');
206         $this->finish();
207     }
208
209     /**
210      * Check runtime memory usage, possibly triggering a graceful shutdown
211      * and thread respawn if we've crossed the soft limit.
212      */
213     protected function checkMemory()
214     {
215         $memoryLimit = $this->softMemoryLimit();
216         if ($memoryLimit > 0) {
217             $usage = memory_get_usage();
218             if ($usage > $memoryLimit) {
219                 common_log(LOG_INFO, "Queue thread hit soft memory limit ($usage > $memoryLimit); gracefully restarting.");
220                 $this->requestRestart();
221             } else if (common_config('queue', 'debug_memory')) {
222                 common_log(LOG_DEBUG, "Memory usage $usage");
223             }
224         }
225     }
226
227     /**
228      * Return fully-parsed soft memory limit in bytes.
229      * @return intval 0 or -1 if not set
230      */
231     function softMemoryLimit()
232     {
233         $softLimit = trim(common_config('queue', 'softlimit'));
234         if (substr($softLimit, -1) == '%') {
235             $limit = $this->parseMemoryLimit(ini_get('memory_limit'));
236             if ($limit > 0) {
237                 return intval(substr($softLimit, 0, -1) * $limit / 100);
238             } else {
239                 return -1;
240             }
241         } else {
242             return $this->parseMemoryLimit($softLimit);
243         }
244         return $softLimit;
245     }
246
247     /**
248      * Interpret PHP shorthand for memory_limit and friends.
249      * Why don't they just expose the actual numeric value? :P
250      * @param string $mem
251      * @return int
252      */
253     public function parseMemoryLimit($mem)
254     {
255         // http://www.php.net/manual/en/faq.using.php#faq.using.shorthandbytes
256         $mem = strtolower(trim($mem));
257         $size = array('k' => 1024,
258                       'm' => 1024*1024,
259                       'g' => 1024*1024*1024);
260         if (empty($mem)) {
261             return 0;
262         } else if (is_numeric($mem)) {
263             return intval($mem);
264         } else {
265             $mult = substr($mem, -1);
266             if (isset($size[$mult])) {
267                 return substr($mem, 0, -1) * $size[$mult];
268             } else {
269                 return intval($mem);
270             }
271         }
272     }
273
274     function start()
275     {
276         foreach ($this->managers as $index => $manager) {
277             $manager->start($this);
278             // @fixme error check
279             if ($manager->pollInterval()) {
280                 // We'll want to check for input on the first pass
281                 $this->pollTimeouts[$index] = 0;
282                 $this->lastPoll[$index] = 0;
283             }
284         }
285     }
286
287     function finish()
288     {
289         foreach ($this->managers as $manager) {
290             $manager->finish();
291             // @fixme error check
292         }
293     }
294
295     /**
296      * Called during the idle portion of the runloop to see which handlers
297      */
298     function poll()
299     {
300         foreach ($this->managers as $index => $manager) {
301             $interval = $manager->pollInterval();
302             if ($interval <= 0) {
303                 // Not a polling manager.
304                 continue;
305             }
306
307             if (isset($this->pollTimeouts[$index])) {
308                 $timeout = $this->pollTimeouts[$index];
309                 if (time() - $this->lastPoll[$index] < $timeout) {
310                     // Not time to poll yet.
311                     continue;
312                 }
313             } else {
314                 $timeout = 0;
315             }
316             $hit = $manager->poll();
317
318             $this->lastPoll[$index] = time();
319             if ($hit) {
320                 // Do the next poll quickly, there may be more input!
321                 $this->pollTimeouts[$index] = 0;
322             } else {
323                 // Empty queue. Exponential backoff up to the maximum poll interval.
324                 if ($timeout > 0) {
325                     $timeout = min($timeout * 2, $interval);
326                 } else {
327                     $timeout = 1;
328                 }
329                 $this->pollTimeouts[$index] = $timeout;
330             }
331         }
332     }
333
334     /**
335      * Called after each handled item or empty polling cycle.
336      * This is a good time to e.g. service your XMPP connection.
337      */
338     function idle()
339     {
340         foreach ($this->managers as $manager) {
341             $manager->idle();
342         }
343     }
344
345     /**
346      * Send thread state update to the monitoring server, if configured.
347      *
348      * @param string $state ('init', 'queue', 'shutdown' etc)
349      * @param string $substate (optional, eg queue name 'omb' 'sms' etc)
350      */
351     protected function logState($state, $substate='')
352     {
353         $this->monitor->logState($this->id, $state, $substate);
354     }
355
356     /**
357      * Send thread stats.
358      * Thread ID will be implicit; other owners can be listed as well
359      * for per-queue and per-site records.
360      *
361      * @param string $key counter name
362      * @param array $owners list of owner keys like 'queue:jabber' or 'site:stat01'
363      */
364     public function stats($key, $owners=array())
365     {
366         $owners[] = "thread:" . $this->id;
367         $this->monitor->stats($key, $owners);
368     }
369
370     /**
371      * For IoManagers to request a graceful shutdown at end of event loop.
372      */
373     public function requestShutdown()
374     {
375         $this->shutdown = true;
376         $this->respawn = false;
377     }
378
379     /**
380      * For IoManagers to request a graceful restart at end of event loop.
381      */
382     public function requestRestart()
383     {
384         $this->shutdown = true;
385         $this->respawn = true;
386     }
387
388 }
389