Ignore:
Timestamp:
Jul 7, 2009, 10:27:37 PM (15 years ago)
Author:
vdigital
Message:

Change: getid3 upgraded to -> 1.7.9

File:
1 edited

Legend:

Unmodified
Added
Removed
  • extensions/charlies_content/getid3/getid3/extension.cache.dbm.php

    r3318 r3544  
    11<?php
    2 // +----------------------------------------------------------------------+
    3 // | PHP version 5                                                        |
    4 // +----------------------------------------------------------------------+
    5 // | Copyright (c) 2002-2006 James Heinrich, Allan Hansen                 |
    6 // +----------------------------------------------------------------------+
    7 // | This source file is subject to version 2 of the GPL license,         |
    8 // | that is bundled with this package in the file license.txt and is     |
    9 // | available through the world-wide-web at the following url:           |
    10 // | http://www.gnu.org/copyleft/gpl.html                                 |
    11 // +----------------------------------------------------------------------+
    12 // | getID3() - http://getid3.sourceforge.net or http://www.getid3.org    |
    13 // +----------------------------------------------------------------------+
    14 // | Authors: James Heinrich <infoØgetid3*org>                            |
    15 // |          Allan Hansen <ahØartemis*dk>                                |
    16 // +----------------------------------------------------------------------+
    17 // | extension.cache.mysql.php                                            |
    18 // | MySQL Cache Extension.                                               |
    19 // | dependencies: getid3.                                                |
    20 // +----------------------------------------------------------------------+
    21 //
    22 // $Id$
     2/////////////////////////////////////////////////////////////////
     3/// getID3() by James Heinrich <info@getid3.org>               //
     4//  available at http://getid3.sourceforge.net                 //
     5//            or http://www.getid3.org                         //
     6/////////////////////////////////////////////////////////////////
     7//                                                             //
     8// extension.cache.dbm.php - part of getID3()                  //
     9// Please see readme.txt for more information                  //
     10//                                                            ///
     11/////////////////////////////////////////////////////////////////
     12//                                                             //
     13// This extension written by Allan Hansen <ahØartemis*dk>      //
     14//                                                            ///
     15/////////////////////////////////////////////////////////////////
    2316
    2417
     
    2720* way as the getID3 class, but return cached information very fast
    2821*
    29 * Example:  (see also demo.cache.dbm.php in /demo/)
     22* Example:
    3023*
    3124*    Normal getID3 usage (example):
    3225*
    3326*       require_once 'getid3/getid3.php';
    34 *       $getid3 = new getid3;
    35 *       $getid3->encoding = 'UTF-8';
    36 *       try {
    37 *           $info1 = $getid3->Analyse('file1.flac');
    38 *           $info2 = $getid3->Analyse('file2.wv');
    39 *           ....
     27*       $getID3 = new getID3;
     28*       $getID3->encoding = 'UTF-8';
     29*       $info1 = $getID3->analyze('file1.flac');
     30*       $info2 = $getID3->analyze('file2.wv');
    4031*
    4132*    getID3_cached usage:
    4233*
    4334*       require_once 'getid3/getid3.php';
    44 *       require_once 'getid3/getid3/extension.cache.mysql.php';
    45 *       $getid3 = new getid3_cached_mysql('localhost', 'database', 'username', 'password');
    46 *       $getid3->encoding = 'UTF-8';
    47 *       try {
    48 *           $info1 = $getid3->analyse('file1.flac');
    49 *           $info2 = $getid3->analyse('file2.wv');
    50 *           ...
     35*       require_once 'getid3/getid3/extension.cache.dbm.php';
     36*       $getID3 = new getID3_cached('db3', '/tmp/getid3_cache.dbm',
     37*                                          '/tmp/getid3_cache.lock');
     38*       $getID3->encoding = 'UTF-8';
     39*       $info1 = $getID3->analyze('file1.flac');
     40*       $info2 = $getID3->analyze('file2.wv');
    5141*
    5242*
     
    8070
    8171
    82 class getid3_cached_dbm extends getid3
     72class getID3_cached_dbm extends getID3
    8373{
    8474
    85     public function __construct($cache_type, $dbm_filename, $lock_filename) {
    86 
    87         // Check for dba extension
    88         if (!extension_loaded('dba')) {
    89             throw new getid3_exception('PHP is not compiled with dba support, required to use DBM style cache.');
    90         }
    91 
    92         if (!in_array($cache_type, dba_handlers())) {
    93             throw new getid3_exception('PHP is not compiled --with '.$cache_type.' support, required to use DBM style cache.');
    94         }
    95 
    96         // Create lock file if needed
    97         if (!file_exists($lock_filename)) {
    98             if (!touch($lock_filename)) {
    99                 die('failed to create lock file: ' . $lock_filename);
    100             }
    101         }
    102 
    103         // Open lock file for writing
    104         if (!is_writeable($lock_filename)) {
    105             die('lock file: ' . $lock_filename . ' is not writable');
    106         }
    107         $this->lock = fopen($lock_filename, 'w');
    108 
    109         // Acquire exclusive write lock to lock file
    110         flock($this->lock, LOCK_EX);
    111 
    112         // Create dbm-file if needed
    113         if (!file_exists($dbm_filename)) {
    114             if (!touch($dbm_filename)) {
    115                 die('failed to create dbm file: ' . $dbm_filename);
    116             }
    117         }
    118 
    119         // Try to open dbm file for writing
    120         $this->dba = @dba_open($dbm_filename, 'w', $cache_type);
    121         if (!$this->dba) {
    122 
    123             // Failed - create new dbm file
    124             $this->dba = dba_open($dbm_filename, 'n', $cache_type);
    125 
    126             if (!$this->dba) {
    127                 die('failed to create dbm file: ' . $dbm_filename);
    128             }
    129 
    130             // Insert getID3 version number
    131             dba_insert(getid3::VERSION, getid3::VERSION, $this->dba);
    132         }
    133 
    134         // Init misc values
    135         $this->cache_type   = $cache_type;
    136         $this->dbm_filename = $dbm_filename;
    137 
    138         // Register destructor
    139         register_shutdown_function(array($this, '__destruct'));
    140 
    141         // Check version number and clear cache if changed
    142         if (dba_fetch(getid3::VERSION, $this->dba) != getid3::VERSION) {
    143             $this->clear_cache();
    144         }
    145 
    146         parent::__construct();
    147     }
    148 
    149 
    150 
    151     public function __destruct() {
    152 
    153         // Close dbm file
    154         @dba_close($this->dba);
    155 
    156         // Release exclusive lock
    157         @flock($this->lock, LOCK_UN);
    158 
    159         // Close lock file
    160         @fclose($this->lock);
    161     }
    162 
    163 
    164 
    165     public function clear_cache() {
    166 
    167         // Close dbm file
    168         dba_close($this->dba);
    169 
    170         // Create new dbm file
    171         $this->dba = dba_open($this->dbm_filename, 'n', $this->cache_type);
    172 
    173         if (!$this->dba) {
    174             die('failed to clear cache/recreate dbm file: ' . $this->dbm_filename);
    175         }
    176 
    177         // Insert getID3 version number
    178         dba_insert(getid3::VERSION, getid3::VERSION, $this->dba);
    179 
    180         // Reregister shutdown function
    181         register_shutdown_function(array($this, '__destruct'));
    182     }
    183 
    184 
    185 
    186     // public: analyze file
    187     public function Analyze($filename) {
    188 
    189         if (file_exists($filename)) {
    190 
    191             // Calc key     filename::mod_time::size    - should be unique
    192             $key = $filename . '::' . filemtime($filename) . '::' . filesize($filename);
    193 
    194             // Loopup key
    195             $result = dba_fetch($key, $this->dba);
    196 
    197             // Hit
    198             if ($result !== false) {
    199                 return unserialize($result);
    200             }
    201         }
    202 
    203         // Miss
    204         $result = parent::Analyze($filename);
    205 
    206         // Save result
    207         if (file_exists($filename)) {
    208             dba_insert($key, serialize($result), $this->dba);
    209         }
    210 
    211         return $result;
    212     }
     75        // public: constructor - see top of this file for cache type and cache_options
     76        function getID3_cached_dbm($cache_type, $dbm_filename, $lock_filename) {
     77
     78                // Check for dba extension
     79                if (!extension_loaded('dba')) {
     80                        die('PHP is not compiled with dba support, required to use DBM style cache.');
     81                }
     82
     83                // Check for specific dba driver
     84                if (function_exists('dba_handlers')) {  // PHP 4.3.0+
     85                        if (!in_array('db3', dba_handlers())) {
     86                                die('PHP is not compiled --with '.$cache_type.' support, required to use DBM style cache.');
     87                        }
     88                }
     89                else { // PHP <= 4.2.3
     90                        ob_start(); // nasty, buy the only way to check...
     91                        phpinfo();
     92                        $contents = ob_get_contents();
     93                        ob_end_clean();
     94                        if (!strstr($contents, $cache_type)) {
     95                                die('PHP is not compiled --with '.$cache_type.' support, required to use DBM style cache.');
     96                        }
     97                }
     98
     99                // Create lock file if needed
     100                if (!file_exists($lock_filename)) {
     101                        if (!touch($lock_filename)) {
     102                                die('failed to create lock file: ' . $lock_filename);
     103                        }
     104                }
     105
     106                // Open lock file for writing
     107                if (!is_writeable($lock_filename)) {
     108                        die('lock file: ' . $lock_filename . ' is not writable');
     109                }
     110                $this->lock = fopen($lock_filename, 'w');
     111
     112                // Acquire exclusive write lock to lock file
     113                flock($this->lock, LOCK_EX);
     114
     115                // Create dbm-file if needed
     116                if (!file_exists($dbm_filename)) {
     117                        if (!touch($dbm_filename)) {
     118                                die('failed to create dbm file: ' . $dbm_filename);
     119                        }
     120                }
     121
     122                // Try to open dbm file for writing
     123                $this->dba = @dba_open($dbm_filename, 'w', $cache_type);
     124                if (!$this->dba) {
     125
     126                        // Failed - create new dbm file
     127                        $this->dba = dba_open($dbm_filename, 'n', $cache_type);
     128
     129                        if (!$this->dba) {
     130                                die('failed to create dbm file: ' . $dbm_filename);
     131                        }
     132
     133                        // Insert getID3 version number
     134                        dba_insert(GETID3_VERSION, GETID3_VERSION, $this->dba);
     135                }
     136
     137                // Init misc values
     138                $this->cache_type   = $cache_type;
     139                $this->dbm_filename = $dbm_filename;
     140
     141                // Register destructor
     142                register_shutdown_function(array($this, '__destruct'));
     143
     144                // Check version number and clear cache if changed
     145                if (dba_fetch(GETID3_VERSION, $this->dba) != GETID3_VERSION) {
     146                        $this->clear_cache();
     147                }
     148
     149                parent::getID3();
     150        }
     151
     152
     153
     154        // public: destuctor
     155        function __destruct() {
     156
     157                // Close dbm file
     158                @dba_close($this->dba);
     159
     160                // Release exclusive lock
     161                @flock($this->lock, LOCK_UN);
     162
     163                // Close lock file
     164                @fclose($this->lock);
     165        }
     166
     167
     168
     169        // public: clear cache
     170        function clear_cache() {
     171
     172                // Close dbm file
     173                dba_close($this->dba);
     174
     175                // Create new dbm file
     176                $this->dba = dba_open($this->dbm_filename, 'n', $this->cache_type);
     177
     178                if (!$this->dba) {
     179                        die('failed to clear cache/recreate dbm file: ' . $this->dbm_filename);
     180                }
     181
     182                // Insert getID3 version number
     183                dba_insert(GETID3_VERSION, GETID3_VERSION, $this->dba);
     184
     185                // Reregister shutdown function
     186                register_shutdown_function(array($this, '__destruct'));
     187        }
     188
     189
     190
     191        // public: analyze file
     192        function analyze($filename) {
     193
     194                if (file_exists($filename)) {
     195
     196                        // Calc key     filename::mod_time::size    - should be unique
     197                        $key = $filename . '::' . filemtime($filename) . '::' . filesize($filename);
     198
     199                        // Loopup key
     200                        $result = dba_fetch($key, $this->dba);
     201
     202                        // Hit
     203                        if ($result !== false) {
     204                                return unserialize($result);
     205                        }
     206                }
     207
     208                // Miss
     209                $result = parent::analyze($filename);
     210
     211                // Save result
     212                if (file_exists($filename)) {
     213                        dba_insert($key, serialize($result), $this->dba);
     214                }
     215
     216                return $result;
     217        }
    213218
    214219}
Note: See TracChangeset for help on using the changeset viewer.