| 1 | <?php |
| 2 | /* |
| 3 | * Copyright (C) 2003-2004 Polytechnique.org |
| 4 | * http://opensource.polytechnique.org/ |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 19 | */ |
| 20 | |
| 21 | // dependency on PEAR |
| 22 | require_once 'System.php'; |
| 23 | |
| 24 | /** This class describes Diogenes' plugins. |
| 25 | */ |
| 26 | class Diogenes_Plugins |
| 27 | { |
| 28 | /** Array of currently loaded plugins */ |
| 29 | var $loaded = array(); |
| 30 | |
| 31 | /** Directory that holds the plugins cache files */ |
| 32 | var $cachedir; |
| 33 | |
| 34 | /** Directory that holds the plugins */ |
| 35 | var $plugdir; |
| 36 | |
| 37 | |
| 38 | /** Constructs a new holder for Diogenes plugins. |
| 39 | * |
| 40 | * @param $dbh |
| 41 | * @param $plugdir |
| 42 | * @param $cachedir |
| 43 | */ |
| 44 | function Diogenes_Plugins(&$dbh, $plugdir, $cachedir) |
| 45 | { |
| 46 | $this->dbh =& $dbh; |
| 47 | $this->plugdir = $plugdir; |
| 48 | $this->cachedir = $cachedir; |
| 49 | } |
| 50 | |
| 51 | |
| 52 | /** Return the path of the cache file |
| 53 | * |
| 54 | * @param $barrel |
| 55 | */ |
| 56 | function cacheFile($barrel) |
| 57 | { |
| 58 | $cachefile = $this->cachedir . "/" . ($barrel ? $barrel : "__diogenes__") . ".plugins"; |
| 59 | return $cachefile; |
| 60 | } |
| 61 | |
| 62 | |
| 63 | /** Return the cache entry for specified plugin |
| 64 | * |
| 65 | * @param $cache |
| 66 | * @param $barrel |
| 67 | * @param $page |
| 68 | * @param $plugin |
| 69 | */ |
| 70 | function cacheGet($cache, $barrel, $page, $plugin) |
| 71 | { |
| 72 | foreach ($cache as $plugentry) |
| 73 | { |
| 74 | if (($plugentry['plugin'] == $plugin) && ($plugentry['page'] == $page)) |
| 75 | { |
| 76 | return $plugentry; |
| 77 | } |
| 78 | } |
| 79 | return; |
| 80 | } |
| 81 | |
| 82 | |
| 83 | /** Return the cache entry for a plugin at a specified position |
| 84 | * |
| 85 | * @param $cache |
| 86 | * @param $barrel |
| 87 | * @param $page |
| 88 | * @param $pos |
| 89 | */ |
| 90 | function cacheGetAtPos($cache, $barrel, $page, $pos) |
| 91 | { |
| 92 | foreach ($cache as $plugentry) |
| 93 | { |
| 94 | if (($plugentry['pos'] == $pos) && ($plugentry['page'] == $page)) |
| 95 | { |
| 96 | return $plugentry; |
| 97 | } |
| 98 | } |
| 99 | } |
| 100 | |
| 101 | |
| 102 | /** List the plugins that are active in a given context |
| 103 | * |
| 104 | * @param $cache |
| 105 | * @param $barrel |
| 106 | * @param $page |
| 107 | */ |
| 108 | function cachedActive($cache, $barrel, $page) |
| 109 | { |
| 110 | $plugins = array(); |
| 111 | foreach ($cache as $plug) |
| 112 | { |
| 113 | if ($plug['page'] == $page) |
| 114 | { |
| 115 | array_push($plugins, $plug); |
| 116 | } |
| 117 | } |
| 118 | return $plugins; |
| 119 | } |
| 120 | |
| 121 | |
| 122 | /** Returns an array of cache entries representing the available plugins |
| 123 | * in a given context |
| 124 | * |
| 125 | * @param $cache |
| 126 | * @param $barrel |
| 127 | * @param $page |
| 128 | */ |
| 129 | function cachedAvailable($cache, $barrel, $page) |
| 130 | { |
| 131 | $available = array(); |
| 132 | foreach ($cache as $plugentry) |
| 133 | { |
| 134 | $plugfile = $this->plugdir."/".$plugentry['plugin'].".php"; |
| 135 | if (file_exists($plugfile) and ($plugentry['page'] == 0) and (!$page or $plugentry['active'])) |
| 136 | { |
| 137 | array_push($available, $plugentry['plugin']); |
| 138 | } |
| 139 | } |
| 140 | return $available; |
| 141 | } |
| 142 | |
| 143 | |
| 144 | /** Remove database references to plugins that are not available. |
| 145 | */ |
| 146 | function clean_database(&$page) |
| 147 | { |
| 148 | /* |
| 149 | $res = $this->dbh->query("select distinct plugin from diogenes_plugin"); |
| 150 | while (list($plugname) = mysql_fetch_row($res)) |
| 151 | { |
| 152 | $page->info("examining $plugname.."); |
| 153 | $plug = $this->load($plugname); |
| 154 | if (!is_object($plug)) { |
| 155 | $page->info("plugin $plugname is broken, removing"); |
| 156 | $this->dbh->query("delete from diogenes_plugin where plugin='$plugname'"); |
| 157 | } |
| 158 | } |
| 159 | mysql_free_result($res); |
| 160 | */ |
| 161 | } |
| 162 | |
| 163 | |
| 164 | /** Compile plugin cache. |
| 165 | * |
| 166 | * @param $cachefile |
| 167 | * @param $barrel |
| 168 | */ |
| 169 | function compileCache($cachefile, $barrel) |
| 170 | { |
| 171 | if (!$fp = fopen($cachefile, "w")) { |
| 172 | trigger_error("failed to open '$cachefile' for writing", E_USER_ERROR); |
| 173 | } |
| 174 | |
| 175 | // get the list of available plugins |
| 176 | $available = array(); |
| 177 | if (!$barrel) { |
| 178 | |
| 179 | $plugfiles = System::find($this->plugdir.' -type f -name *.php'); |
| 180 | foreach ($plugfiles as $file) { |
| 181 | $name = basename($file); |
| 182 | $name = substr($name, 0, -4); |
| 183 | array_push($available, $name); |
| 184 | } |
| 185 | |
| 186 | } else { |
| 187 | |
| 188 | $sql = "select plugin from diogenes_plugin where page=0 AND barrel=''"; |
| 189 | $res = $this->dbh->query($sql); |
| 190 | while (list($plugin) = mysql_fetch_row($res)) |
| 191 | { |
| 192 | array_push($available, $plugin); |
| 193 | } |
| 194 | mysql_free_result($res); |
| 195 | } |
| 196 | |
| 197 | /* |
| 198 | echo "compile : available <pre>"; |
| 199 | print_r($available); |
| 200 | echo "</pre>"; |
| 201 | */ |
| 202 | // get active plugins |
| 203 | $sql = "select page, pos, plugin, params from diogenes_plugin where barrel='{$barrel}' order by page, pos"; |
| 204 | $res = $this->dbh->query($sql); |
| 205 | $active = array(); |
| 206 | while ($row = mysql_fetch_row($res)) |
| 207 | { |
| 208 | $plugin = $row[2]; |
| 209 | if (in_array($plugin, $available)) { |
| 210 | array_unshift($row, 1); |
| 211 | fputs($fp, join("\t", $row) . "\n"); |
| 212 | if (!$row[1]) { |
| 213 | array_push($active, $plugin); |
| 214 | //echo "compileCache : adding active plugin $plugin<br/>"; |
| 215 | } |
| 216 | } |
| 217 | } |
| 218 | mysql_free_result($res); |
| 219 | |
| 220 | // add inactive plugins |
| 221 | foreach ($available as $plugin) |
| 222 | { |
| 223 | if (!in_array($plugin, $active)) |
| 224 | { |
| 225 | //echo "compileCache : adding inactive plugin $plugin<br/>"; |
| 226 | $row = array(0, 0, 0, $plugin, ''); |
| 227 | fputs($fp, join("\t", $row) . "\n"); |
| 228 | } |
| 229 | } |
| 230 | |
| 231 | fclose($fp); |
| 232 | |
| 233 | //$this->log("rcs_commit","{$this->alias}:$dir/$file:$message"); |
| 234 | |
| 235 | } |
| 236 | |
| 237 | |
| 238 | /** Load the specified plugin |
| 239 | * |
| 240 | * @param $plugentry |
| 241 | */ |
| 242 | function load($plugentry) |
| 243 | { |
| 244 | $plugin = $plugentry['plugin']; |
| 245 | $plugfile = $this->plugdir."/$plugin.php"; |
| 246 | if (!file_exists($plugfile)) { |
| 247 | trigger_error("could not find plugin file '$plugfile'", E_USER_WARNING); |
| 248 | return; |
| 249 | } |
| 250 | |
| 251 | include_once($plugfile); |
| 252 | |
| 253 | if (!class_exists($plugin)) { |
| 254 | trigger_error("could not find class '$plugin'", E_USER_WARNING); |
| 255 | return; |
| 256 | } |
| 257 | |
| 258 | // load and register plugin |
| 259 | $plug = new $plugin(); |
| 260 | $plug->pos = $plugentry['pos']; |
| 261 | $plug->active = $plugentry['active']; |
| 262 | $plug->setParams($plugentry['params']); |
| 263 | $this->loaded[$plugin] =& $plug; |
| 264 | |
| 265 | return $plug; |
| 266 | } |
| 267 | |
| 268 | |
| 269 | /** Read the compiled plugin cache |
| 270 | * |
| 271 | * @param $cachefile |
| 272 | * @param $barrel |
| 273 | */ |
| 274 | function readCache($cachefile, $barrel) |
| 275 | { |
| 276 | if (!file_exists($cachefile)) { |
| 277 | return array(); |
| 278 | } |
| 279 | |
| 280 | if (!$fp = fopen($cachefile, "r")) { |
| 281 | trigger_error("failed to open '$cachefile' for reading", E_USER_WARNING); |
| 282 | return; |
| 283 | } |
| 284 | |
| 285 | $plugins = array(); |
| 286 | while ($line = fgets($fp)) |
| 287 | { |
| 288 | // drop end of line |
| 289 | $line = substr($line, 0, -1); |
| 290 | $bits = explode("\t", $line); |
| 291 | $plug = array( |
| 292 | 'active' => $bits[0], |
| 293 | 'page' => $bits[1], |
| 294 | 'pos' => $bits[2], |
| 295 | 'plugin' => $bits[3], |
| 296 | 'params' => $bits[4], |
| 297 | ); |
| 298 | array_push($plugins, $plug); |
| 299 | } |
| 300 | |
| 301 | fclose($fp); |
| 302 | |
| 303 | return $plugins; |
| 304 | } |
| 305 | |
| 306 | |
| 307 | /** Prepare plugins trace for output |
| 308 | */ |
| 309 | function trace_format() |
| 310 | { |
| 311 | $out = ""; |
| 312 | foreach ($this->loaded as $key => $val) |
| 313 | { |
| 314 | $out .= '<table class="light" style="width: 100%; font-family: monospace">'; |
| 315 | $out .= '<tr><th colspan="2">'.$key.' v'.$val->version.'</th></tr>'; |
| 316 | if (isset($val->pos)) { |
| 317 | $out .= '<tr><td>position</td><td>'.$val->pos.'</td></tr>'; |
| 318 | } |
| 319 | $out .= '<tr><td>type</td><td>'.$val->type.'</td></tr>'; |
| 320 | $out .= '<tr><td>description</td><td>'.$val->description.'</td></tr>'; |
| 321 | if (empty($val->params)) { |
| 322 | $out .= '<tr class="odd"><td colspan="2">parameters</td></tr>'; |
| 323 | foreach ($val->params as $skey => $sval) |
| 324 | { |
| 325 | $out .= "<tr><td>$skey</td><td>$sval</td></tr>"; |
| 326 | } |
| 327 | } |
| 328 | $out .= "</table><br/>"; |
| 329 | } |
| 330 | return $out; |
| 331 | } |
| 332 | |
| 333 | |
| 334 | |
| 335 | } |
| 336 | |
| 337 | ?> |