diff options
Diffstat (limited to 'includes/externalstore')
| -rw-r--r-- | includes/externalstore/ExternalStore.php | 227 | ||||
| -rw-r--r-- | includes/externalstore/ExternalStoreDB.php | 283 | ||||
| -rw-r--r-- | includes/externalstore/ExternalStoreHttp.php | 43 | ||||
| -rw-r--r-- | includes/externalstore/ExternalStoreMedium.php | 79 | ||||
| -rw-r--r-- | includes/externalstore/ExternalStoreMwstore.php | 95 |
5 files changed, 727 insertions, 0 deletions
diff --git a/includes/externalstore/ExternalStore.php b/includes/externalstore/ExternalStore.php new file mode 100644 index 00000000..462b0b90 --- /dev/null +++ b/includes/externalstore/ExternalStore.php @@ -0,0 +1,227 @@ +<?php +/** + * @defgroup ExternalStorage ExternalStorage + */ + +/** + * Interface for data storage in external repositories. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * http://www.gnu.org/copyleft/gpl.html + * + * @file + */ + +/** + * Constructor class for key/value blob data kept in external repositories. + * + * Objects in external stores are defined by a special URL. The URL is of + * the form "<store protocol>://<location>/<object name>". The protocol is used + * to determine what ExternalStoreMedium class is used. The location identifies + * particular storage instances or database clusters for store class to use. + * + * When an object is inserted into a store, the calling code uses a partial URL of + * the form "<store protocol>://<location>" and receives the full object URL on success. + * This is useful since object names can be sequential IDs, UUIDs, or hashes. + * Callers are not responsible for unique name generation. + * + * External repositories might be populated by maintenance/async + * scripts, thus partial moving of data may be possible, as well + * as the possibility to have any storage format (i.e. for archives). + * + * @ingroup ExternalStorage + */ +class ExternalStore { + /** + * Get an external store object of the given type, with the given parameters + * + * @param string $proto Type of external storage, should be a value in $wgExternalStores + * @param array $params Associative array of ExternalStoreMedium parameters + * @return ExternalStoreMedium|bool The store class or false on error + */ + public static function getStoreObject( $proto, array $params = array() ) { + global $wgExternalStores; + + if ( !$wgExternalStores || !in_array( $proto, $wgExternalStores ) ) { + return false; // protocol not enabled + } + + $class = 'ExternalStore' . ucfirst( $proto ); + // Any custom modules should be added to $wgAutoLoadClasses for on-demand loading + return class_exists( $class ) ? new $class( $params ) : false; + } + + /** + * Fetch data from given URL + * + * @param string $url The URL of the text to get + * @param array $params Associative array of ExternalStoreMedium parameters + * @return string|bool The text stored or false on error + * @throws MWException + */ + public static function fetchFromURL( $url, array $params = array() ) { + $parts = explode( '://', $url, 2 ); + if ( count( $parts ) != 2 ) { + return false; // invalid URL + } + + list( $proto, $path ) = $parts; + if ( $path == '' ) { // bad URL + return false; + } + + $store = self::getStoreObject( $proto, $params ); + if ( $store === false ) { + return false; + } + + return $store->fetchFromURL( $url ); + } + + /** + * Fetch data from multiple URLs with a minimum of round trips + * + * @param array $urls The URLs of the text to get + * @return array Map from url to its data. Data is either string when found + * or false on failure. + */ + public static function batchFetchFromURLs( array $urls ) { + $batches = array(); + foreach ( $urls as $url ) { + $scheme = parse_url( $url, PHP_URL_SCHEME ); + if ( $scheme ) { + $batches[$scheme][] = $url; + } + } + $retval = array(); + foreach ( $batches as $proto => $batchedUrls ) { + $store = self::getStoreObject( $proto ); + if ( $store === false ) { + continue; + } + $retval += $store->batchFetchFromURLs( $batchedUrls ); + } + // invalid, not found, db dead, etc. + $missing = array_diff( $urls, array_keys( $retval ) ); + if ( $missing ) { + foreach ( $missing as $url ) { + $retval[$url] = false; + } + } + return $retval; + } + + /** + * Store a data item to an external store, identified by a partial URL + * The protocol part is used to identify the class, the rest is passed to the + * class itself as a parameter. + * + * @param string $url A partial external store URL ("<store type>://<location>") + * @param $data string + * @param array $params Associative array of ExternalStoreMedium parameters + * @return string|bool The URL of the stored data item, or false on error + * @throws MWException + */ + public static function insert( $url, $data, array $params = array() ) { + $parts = explode( '://', $url, 2 ); + if ( count( $parts ) != 2 ) { + return false; // invalid URL + } + + list( $proto, $path ) = $parts; + if ( $path == '' ) { // bad URL + return false; + } + + $store = self::getStoreObject( $proto, $params ); + if ( $store === false ) { + return false; + } else { + return $store->store( $path, $data ); + } + } + + /** + * Like insert() above, but does more of the work for us. + * This function does not need a url param, it builds it by + * itself. It also fails-over to the next possible clusters + * provided by $wgDefaultExternalStore. + * + * @param string $data + * @param array $params Associative array of ExternalStoreMedium parameters + * @return string|bool The URL of the stored data item, or false on error + * @throws MWException + */ + public static function insertToDefault( $data, array $params = array() ) { + global $wgDefaultExternalStore; + + return self::insertWithFallback( (array)$wgDefaultExternalStore, $data, $params ); + } + + /** + * Like insert() above, but does more of the work for us. + * This function does not need a url param, it builds it by + * itself. It also fails-over to the next possible clusters + * as provided in the first parameter. + * + * @param array $tryStores refer to $wgDefaultExternalStore + * @param string $data + * @param array $params Associative array of ExternalStoreMedium parameters + * @return string|bool The URL of the stored data item, or false on error + * @throws MWException + */ + public static function insertWithFallback( array $tryStores, $data, array $params = array() ) { + $error = false; + while ( count( $tryStores ) > 0 ) { + $index = mt_rand( 0, count( $tryStores ) - 1 ); + $storeUrl = $tryStores[$index]; + wfDebug( __METHOD__ . ": trying $storeUrl\n" ); + list( $proto, $path ) = explode( '://', $storeUrl, 2 ); + $store = self::getStoreObject( $proto, $params ); + if ( $store === false ) { + throw new MWException( "Invalid external storage protocol - $storeUrl" ); + } + try { + $url = $store->store( $path, $data ); // Try to save the object + } catch ( MWException $error ) { + $url = false; + } + if ( strlen( $url ) ) { + return $url; // Done! + } else { + unset( $tryStores[$index] ); // Don't try this one again! + $tryStores = array_values( $tryStores ); // Must have consecutive keys + wfDebugLog( 'ExternalStorage', + "Unable to store text to external storage $storeUrl" ); + } + } + // All stores failed + if ( $error ) { + throw $error; // rethrow the last error + } else { + throw new MWException( "Unable to store text to external storage" ); + } + } + + /** + * @param $data string + * @param $wiki string + * @return string|bool The URL of the stored data item, or false on error + * @throws MWException + */ + public static function insertToForeignDefault( $data, $wiki ) { + return self::insertToDefault( $data, array( 'wiki' => $wiki ) ); + } +} diff --git a/includes/externalstore/ExternalStoreDB.php b/includes/externalstore/ExternalStoreDB.php new file mode 100644 index 00000000..46a89379 --- /dev/null +++ b/includes/externalstore/ExternalStoreDB.php @@ -0,0 +1,283 @@ +<?php +/** + * External storage in SQL database. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * http://www.gnu.org/copyleft/gpl.html + * + * @file + */ + +/** + * DB accessable external objects. + * + * In this system, each store "location" maps to a database "cluster". + * The clusters must be defined in the normal LBFactory configuration. + * + * @ingroup ExternalStorage + */ +class ExternalStoreDB extends ExternalStoreMedium { + /** + * The provided URL is in the form of DB://cluster/id + * or DB://cluster/id/itemid for concatened storage. + * + * @see ExternalStoreMedium::fetchFromURL() + */ + public function fetchFromURL( $url ) { + list( $cluster, $id, $itemID ) = $this->parseURL( $url ); + $ret =& $this->fetchBlob( $cluster, $id, $itemID ); + + if ( $itemID !== false && $ret !== false ) { + return $ret->getItem( $itemID ); + } + return $ret; + } + + /** + * Fetch data from given external store URLs. + * The provided URLs are in the form of DB://cluster/id + * or DB://cluster/id/itemid for concatened storage. + * + * @param array $urls An array of external store URLs + * @return array A map from url to stored content. Failed results + * are not represented. + */ + public function batchFetchFromURLs( array $urls ) { + $batched = $inverseUrlMap = array(); + foreach ( $urls as $url ) { + list( $cluster, $id, $itemID ) = $this->parseURL( $url ); + $batched[$cluster][$id][] = $itemID; + // false $itemID gets cast to int, but should be ok + // since we do === from the $itemID in $batched + $inverseUrlMap[$cluster][$id][$itemID] = $url; + } + $ret = array(); + foreach ( $batched as $cluster => $batchByCluster ) { + $res = $this->batchFetchBlobs( $cluster, $batchByCluster ); + foreach ( $res as $id => $blob ) { + foreach ( $batchByCluster[$id] as $itemID ) { + $url = $inverseUrlMap[$cluster][$id][$itemID]; + if ( $itemID === false ) { + $ret[$url] = $blob; + } else { + $ret[$url] = $blob->getItem( $itemID ); + } + } + } + } + return $ret; + } + + /** + * @see ExternalStoreMedium::store() + */ + public function store( $cluster, $data ) { + $dbw = $this->getMaster( $cluster ); + $id = $dbw->nextSequenceValue( 'blob_blob_id_seq' ); + $dbw->insert( $this->getTable( $dbw ), + array( 'blob_id' => $id, 'blob_text' => $data ), + __METHOD__ ); + $id = $dbw->insertId(); + if ( !$id ) { + throw new MWException( __METHOD__ . ': no insert ID' ); + } + if ( $dbw->getFlag( DBO_TRX ) ) { + $dbw->commit( __METHOD__ ); + } + return "DB://$cluster/$id"; + } + + /** + * Get a LoadBalancer for the specified cluster + * + * @param string $cluster cluster name + * @return LoadBalancer object + */ + function &getLoadBalancer( $cluster ) { + $wiki = isset( $this->params['wiki'] ) ? $this->params['wiki'] : false; + + return wfGetLBFactory()->getExternalLB( $cluster, $wiki ); + } + + /** + * Get a slave database connection for the specified cluster + * + * @param string $cluster cluster name + * @return DatabaseBase object + */ + function &getSlave( $cluster ) { + global $wgDefaultExternalStore; + + $wiki = isset( $this->params['wiki'] ) ? $this->params['wiki'] : false; + $lb =& $this->getLoadBalancer( $cluster ); + + if ( !in_array( "DB://" . $cluster, (array)$wgDefaultExternalStore ) ) { + wfDebug( "read only external store" ); + $lb->allowLagged( true ); + } else { + wfDebug( "writable external store" ); + } + + return $lb->getConnection( DB_SLAVE, array(), $wiki ); + } + + /** + * Get a master database connection for the specified cluster + * + * @param string $cluster cluster name + * @return DatabaseBase object + */ + function &getMaster( $cluster ) { + $wiki = isset( $this->params['wiki'] ) ? $this->params['wiki'] : false; + $lb =& $this->getLoadBalancer( $cluster ); + return $lb->getConnection( DB_MASTER, array(), $wiki ); + } + + /** + * Get the 'blobs' table name for this database + * + * @param $db DatabaseBase + * @return String: table name ('blobs' by default) + */ + function getTable( &$db ) { + $table = $db->getLBInfo( 'blobs table' ); + if ( is_null( $table ) ) { + $table = 'blobs'; + } + return $table; + } + + /** + * Fetch a blob item out of the database; a cache of the last-loaded + * blob will be kept so that multiple loads out of a multi-item blob + * can avoid redundant database access and decompression. + * @param $cluster + * @param $id + * @param $itemID + * @return mixed + * @private + */ + function &fetchBlob( $cluster, $id, $itemID ) { + /** + * One-step cache variable to hold base blobs; operations that + * pull multiple revisions may often pull multiple times from + * the same blob. By keeping the last-used one open, we avoid + * redundant unserialization and decompression overhead. + */ + static $externalBlobCache = array(); + + $cacheID = ( $itemID === false ) ? "$cluster/$id" : "$cluster/$id/"; + if ( isset( $externalBlobCache[$cacheID] ) ) { + wfDebugLog( 'ExternalStoreDB-cache', + "ExternalStoreDB::fetchBlob cache hit on $cacheID\n" ); + return $externalBlobCache[$cacheID]; + } + + wfDebugLog( 'ExternalStoreDB-cache', + "ExternalStoreDB::fetchBlob cache miss on $cacheID\n" ); + + $dbr =& $this->getSlave( $cluster ); + $ret = $dbr->selectField( $this->getTable( $dbr ), + 'blob_text', array( 'blob_id' => $id ), __METHOD__ ); + if ( $ret === false ) { + wfDebugLog( 'ExternalStoreDB', + "ExternalStoreDB::fetchBlob master fallback on $cacheID\n" ); + // Try the master + $dbw =& $this->getMaster( $cluster ); + $ret = $dbw->selectField( $this->getTable( $dbw ), + 'blob_text', array( 'blob_id' => $id ), __METHOD__ ); + if ( $ret === false ) { + wfDebugLog( 'ExternalStoreDB', + "ExternalStoreDB::fetchBlob master failed to find $cacheID\n" ); + } + } + if ( $itemID !== false && $ret !== false ) { + // Unserialise object; caller extracts item + $ret = unserialize( $ret ); + } + + $externalBlobCache = array( $cacheID => &$ret ); + return $ret; + } + + /** + * Fetch multiple blob items out of the database + * + * @param string $cluster A cluster name valid for use with LBFactory + * @param array $ids A map from the blob_id's to look for to the requested itemIDs in the blobs + * @return array A map from the blob_id's requested to their content. Unlocated ids are not represented + */ + function batchFetchBlobs( $cluster, array $ids ) { + $dbr = $this->getSlave( $cluster ); + $res = $dbr->select( $this->getTable( $dbr ), + array( 'blob_id', 'blob_text' ), array( 'blob_id' => array_keys( $ids ) ), __METHOD__ ); + $ret = array(); + if ( $res !== false ) { + $this->mergeBatchResult( $ret, $ids, $res ); + } + if ( $ids ) { + wfDebugLog( __CLASS__, __METHOD__ . + " master fallback on '$cluster' for: " . + implode( ',', array_keys( $ids ) ) . "\n" ); + // Try the master + $dbw = $this->getMaster( $cluster ); + $res = $dbw->select( $this->getTable( $dbr ), + array( 'blob_id', 'blob_text' ), + array( 'blob_id' => array_keys( $ids ) ), + __METHOD__ ); + if ( $res === false ) { + wfDebugLog( __CLASS__, __METHOD__ . " master failed on '$cluster'\n" ); + } else { + $this->mergeBatchResult( $ret, $ids, $res ); + } + } + if ( $ids ) { + wfDebugLog( __CLASS__, __METHOD__ . + " master on '$cluster' failed locating items: " . + implode( ',', array_keys( $ids ) ) . "\n" ); + } + return $ret; + } + + /** + * Helper function for self::batchFetchBlobs for merging master/slave results + * @param array &$ret Current self::batchFetchBlobs return value + * @param array &$ids Map from blob_id to requested itemIDs + * @param mixed $res DB result from DatabaseBase::select + */ + private function mergeBatchResult( array &$ret, array &$ids, $res ) { + foreach ( $res as $row ) { + $id = $row->blob_id; + $itemIDs = $ids[$id]; + unset( $ids[$id] ); // to track if everything is found + if ( count( $itemIDs ) === 1 && reset( $itemIDs ) === false ) { + // single result stored per blob + $ret[$id] = $row->blob_text; + } else { + // multi result stored per blob + $ret[$id] = unserialize( $row->blob_text ); + } + } + } + + protected function parseURL( $url ) { + $path = explode( '/', $url ); + return array( + $path[2], // cluster + $path[3], // id + isset( $path[4] ) ? $path[4] : false // itemID + ); + } +} diff --git a/includes/externalstore/ExternalStoreHttp.php b/includes/externalstore/ExternalStoreHttp.php new file mode 100644 index 00000000..345c17be --- /dev/null +++ b/includes/externalstore/ExternalStoreHttp.php @@ -0,0 +1,43 @@ +<?php +/** + * External storage using HTTP requests. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * http://www.gnu.org/copyleft/gpl.html + * + * @file + */ + +/** + * Example class for HTTP accessable external objects. + * Only supports reading, not storing. + * + * @ingroup ExternalStorage + */ +class ExternalStoreHttp extends ExternalStoreMedium { + /** + * @see ExternalStoreMedium::fetchFromURL() + */ + public function fetchFromURL( $url ) { + return Http::get( $url ); + } + + /** + * @see ExternalStoreMedium::store() + */ + public function store( $cluster, $data ) { + throw new MWException( "ExternalStoreHttp is read-only and does not support store()." ); + } +} diff --git a/includes/externalstore/ExternalStoreMedium.php b/includes/externalstore/ExternalStoreMedium.php new file mode 100644 index 00000000..02bdcb51 --- /dev/null +++ b/includes/externalstore/ExternalStoreMedium.php @@ -0,0 +1,79 @@ +<?php +/** + * External storage in some particular medium. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * http://www.gnu.org/copyleft/gpl.html + * + * @file + * @ingroup ExternalStorage + * @author Aaron Schulz + */ + +/** + * Accessable external objects in a particular storage medium + * + * @ingroup ExternalStorage + * @since 1.21 + */ +abstract class ExternalStoreMedium { + /** @var Array */ + protected $params = array(); + + /** + * @param array $params Options + */ + public function __construct( array $params = array() ) { + $this->params = $params; + } + + /** + * Fetch data from given external store URL + * + * @param string $url An external store URL + * @return string|bool The text stored or false on error + * @throws MWException + */ + abstract public function fetchFromURL( $url ); + + /** + * Fetch data from given external store URLs. + * + * @param array $urls A list of external store URLs + * @return array Map from the url to the text stored. Unfound data is not represented + */ + public function batchFetchFromURLs( array $urls ) { + $retval = array(); + foreach ( $urls as $url ) { + $data = $this->fetchFromURL( $url ); + // Dont return when false to allow for simpler implementations. + // errored urls are handled in ExternalStore::batchFetchFromURLs + if ( $data !== false ) { + $retval[$urls] = $data; + } + } + return $retval; + } + + /** + * Insert a data item into a given location + * + * @param string $location the location name + * @param string $data the data item + * @return string|bool The URL of the stored data item, or false on error + * @throws MWException + */ + abstract public function store( $location, $data ); +} diff --git a/includes/externalstore/ExternalStoreMwstore.php b/includes/externalstore/ExternalStoreMwstore.php new file mode 100644 index 00000000..aa486796 --- /dev/null +++ b/includes/externalstore/ExternalStoreMwstore.php @@ -0,0 +1,95 @@ +<?php +/** + * External storage in a file backend. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * http://www.gnu.org/copyleft/gpl.html + * + * @file + */ + +/** + * File backend accessable external objects. + * + * In this system, each store "location" maps to the name of a file backend. + * The file backends must be defined in $wgFileBackends and must be global + * and fully qualified with a global "wikiId" prefix in the configuration. + * + * @ingroup ExternalStorage + * @since 1.21 + */ +class ExternalStoreMwstore extends ExternalStoreMedium { + /** + * The URL returned is of the form of the form mwstore://backend/container/wiki/id + * + * @see ExternalStoreMedium::fetchFromURL() + */ + public function fetchFromURL( $url ) { + $be = FileBackendGroup::singleton()->backendFromPath( $url ); + if ( $be instanceof FileBackend ) { + // We don't need "latest" since objects are immutable and + // backends should at least have "read-after-create" consistency. + return $be->getFileContents( array( 'src' => $url ) ); + } + return false; + } + + /** + * Fetch data from given external store URLs. + * The URL returned is of the form of the form mwstore://backend/container/wiki/id + * + * @param array $urls An array of external store URLs + * @return array A map from url to stored content. Failed results are not represented. + */ + public function batchFetchFromURLs( array $urls ) { + $pathsByBackend = array(); + foreach ( $urls as $url ) { + $be = FileBackendGroup::singleton()->backendFromPath( $url ); + if ( $be instanceof FileBackend ) { + $pathsByBackend[$be->getName()][] = $url; + } + } + $blobs = array(); + foreach ( $pathsByBackend as $backendName => $paths ) { + $be = FileBackendGroup::get( $backendName ); + $blobs = $blobs + $be->getFileContentsMulti( array( 'srcs' => $paths ) ); + } + return $blobs; + } + + /** + * @see ExternalStoreMedium::store() + */ + public function store( $backend, $data ) { + $be = FileBackendGroup::singleton()->get( $backend ); + if ( $be instanceof FileBackend ) { + // Get three random base 36 characters to act as shard directories + $rand = wfBaseConvert( mt_rand( 0, 46655 ), 10, 36, 3 ); + // Make sure ID is roughly lexicographically increasing for performance + $id = str_pad( UIDGenerator::newTimestampedUID128( 32 ), 26, '0', STR_PAD_LEFT ); + // Segregate items by wiki ID for the sake of bookkeeping + $wiki = isset( $this->params['wiki'] ) ? $this->params['wiki'] : wfWikiID(); + + $url = $be->getContainerStoragePath( 'data' ) . '/' . + rawurlencode( $wiki ) . "/{$rand[0]}/{$rand[1]}/{$rand[2]}/{$id}"; + + $be->prepare( array( 'dir' => dirname( $url ), 'noAccess' => 1, 'noListing' => 1 ) ); + if ( $be->create( array( 'dst' => $url, 'content' => $data ) )->isOK() ) { + return $url; + } + } + return false; + } +} |