mirror of
https://github.com/yiisoft/yii.git
synced 2026-03-03 14:54:04 +01:00
228 lines
7.6 KiB
PHP
228 lines
7.6 KiB
PHP
<?php
|
|
/**
|
|
* CAssetManager class file.
|
|
*
|
|
* @author Qiang Xue <qiang.xue@gmail.com>
|
|
* @link http://www.yiiframework.com/
|
|
* @copyright Copyright © 2008-2009 Yii Software LLC
|
|
* @license http://www.yiiframework.com/license/
|
|
*/
|
|
|
|
|
|
/**
|
|
* CAssetManager is a Web application component that manages private files (called assets) and makes them accessible by Web clients.
|
|
*
|
|
* It achieves this goal by copying assets to a Web-accessible directory
|
|
* and returns the corresponding URL for accessing them.
|
|
*
|
|
* To publish an asset, simply call {@link publish()}.
|
|
*
|
|
* The Web-accessible directory holding the published files is specified
|
|
* by {@link setBasePath basePath}, which defaults to the "assets" directory
|
|
* under the directory containing the application entry script file.
|
|
* The property {@link setBaseUrl baseUrl} refers to the URL for accessing
|
|
* the {@link setBasePath basePath}.
|
|
*
|
|
* @author Qiang Xue <qiang.xue@gmail.com>
|
|
* @version $Id$
|
|
* @package system.web
|
|
* @since 1.0
|
|
*/
|
|
class CAssetManager extends CApplicationComponent
|
|
{
|
|
/**
|
|
* Default web accessible base path for storing private files
|
|
*/
|
|
const DEFAULT_BASEPATH='assets';
|
|
/**
|
|
* @var string base web accessible path for storing private files
|
|
*/
|
|
private $_basePath;
|
|
/**
|
|
* @var string base URL for accessing the publishing directory.
|
|
*/
|
|
private $_baseUrl;
|
|
/**
|
|
* @var array published assets
|
|
*/
|
|
private $_published=array();
|
|
|
|
/**
|
|
* Initializes the application component.
|
|
* This method is required by IApplicationComponent and is invoked by application.
|
|
*/
|
|
public function init()
|
|
{
|
|
parent::init();
|
|
$request=Yii::app()->getRequest();
|
|
if($this->getBasePath()===null)
|
|
$this->setBasePath(dirname($request->getScriptFile()).DIRECTORY_SEPARATOR.self::DEFAULT_BASEPATH);
|
|
if($this->getBaseUrl()===null)
|
|
$this->setBaseUrl($request->getBaseUrl().'/'.self::DEFAULT_BASEPATH);
|
|
}
|
|
|
|
/**
|
|
* @return string the root directory storing the published asset files
|
|
*/
|
|
public function getBasePath()
|
|
{
|
|
return $this->_basePath;
|
|
}
|
|
|
|
/**
|
|
* Sets the root directory storing published asset files.
|
|
* @param string the root directory storing published asset files
|
|
* @throws CException if the base path is invalid
|
|
*/
|
|
public function setBasePath($value)
|
|
{
|
|
if(($basePath=realpath($value))!==false && is_dir($basePath) && is_writable($basePath))
|
|
$this->_basePath=$basePath;
|
|
else
|
|
throw new CException(Yii::t('yii','CAssetManager.basePath "{path}" is invalid. Please make sure the directory exists and is writable by the Web server process.',
|
|
array('{path}'=>$value)));
|
|
}
|
|
|
|
/**
|
|
* @return string the base url that the published asset files can be accessed.
|
|
* Note, the ending slashes are stripped off.
|
|
*/
|
|
public function getBaseUrl()
|
|
{
|
|
return $this->_baseUrl;
|
|
}
|
|
|
|
/**
|
|
* @param string the base url that the published asset files can be accessed
|
|
*/
|
|
public function setBaseUrl($value)
|
|
{
|
|
$this->_baseUrl=rtrim($value,'/');
|
|
}
|
|
|
|
/**
|
|
* Publishes a file or a directory.
|
|
* This method will copy the specified asset to a web accessible directory
|
|
* and return the URL for accessing the published asset.
|
|
* <ul>
|
|
* <li>If the asset is a file, its file modification time will be checked
|
|
* to avoid unnecessary file copying;</li>
|
|
* <li>If the asset is a directory, all files and subdirectories under it will
|
|
* be published recursively. Note, in this case the method only checks the
|
|
* existence of the target directory to avoid repetitive copying.</li>
|
|
* </ul>
|
|
* @param string the asset (file or directory) to be published
|
|
* @param boolean whether the published directory should be named as the hashed basename.
|
|
* If false, the name will be the hashed dirname of the path being published.
|
|
* Defaults to false. Set true if the path being published is shared among
|
|
* different extensions.
|
|
* @param integer level of recursive copying when the asset is a directory.
|
|
* Level -1 means publishing all subdirectories and files;
|
|
* Level 0 means publishing only the files DIRECTLY under the directory;
|
|
* level N means copying those directories that are within N levels.
|
|
* @return string an absolute URL to the published asset
|
|
* @throws CException if the asset to be published does not exist.
|
|
*/
|
|
public function publish($path,$hashByName=false,$level=-1)
|
|
{
|
|
if(isset($this->_published[$path]))
|
|
return $this->_published[$path];
|
|
else if(($src=realpath($path))!==false)
|
|
{
|
|
if(is_file($src))
|
|
{
|
|
$dir=$this->hash($hashByName ? basename($src) : dirname($src));
|
|
$fileName=basename($src);
|
|
$dstDir=$this->getBasePath().DIRECTORY_SEPARATOR.$dir;
|
|
$dstFile=$dstDir.DIRECTORY_SEPARATOR.$fileName;
|
|
|
|
if(@filemtime($dstFile)<@filemtime($src))
|
|
{
|
|
if(!is_dir($dstDir))
|
|
{
|
|
mkdir($dstDir);
|
|
@chmod($dstDir,0777);
|
|
}
|
|
copy($src,$dstFile);
|
|
}
|
|
|
|
return $this->_published[$path]=$this->getBaseUrl()."/$dir/$fileName";
|
|
}
|
|
else if(is_dir($src))
|
|
{
|
|
$dir=$this->hash($hashByName ? basename($src) : $src);
|
|
$dstDir=$this->getBasePath().DIRECTORY_SEPARATOR.$dir;
|
|
|
|
if(!is_dir($dstDir))
|
|
CFileHelper::copyDirectory($src,$dstDir,array('exclude'=>array('.svn'),'level'=>$level));
|
|
|
|
return $this->_published[$path]=$this->getBaseUrl().'/'.$dir;
|
|
}
|
|
}
|
|
throw new CException(Yii::t('yii','The asset "{asset}" to be published does not exist.',
|
|
array('{asset}'=>$path)));
|
|
}
|
|
|
|
/**
|
|
* Returns the published path of a file path.
|
|
* This method does not perform any publishing. It merely tells you
|
|
* if the file or directory is published, where it will go.
|
|
* @param string directory or file path being published
|
|
* @param boolean whether the published directory should be named as the hashed basename.
|
|
* If false, the name will be the hashed dirname of the path being published.
|
|
* Defaults to false. Set true if the path being published is shared among
|
|
* different extensions.
|
|
* @return string the published file path. False if the file or directory does not exist
|
|
*/
|
|
public function getPublishedPath($path,$hashByName=false)
|
|
{
|
|
if(($path=realpath($path))!==false)
|
|
{
|
|
$base=$this->getBasePath().DIRECTORY_SEPARATOR;
|
|
if(is_file($path))
|
|
return $base . $this->hash($hashByName ? basename($path) : dirname($path)) . DIRECTORY_SEPARATOR . basename($path);
|
|
else
|
|
return $base . $this->hash($hashByName ? basename($path) : $path);
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns the URL of a published file path.
|
|
* This method does not perform any publishing. It merely tells you
|
|
* if the file path is published, what the URL will be to access it.
|
|
* @param string directory or file path being published
|
|
* @param boolean whether the published directory should be named as the hashed basename.
|
|
* If false, the name will be the hashed dirname of the path being published.
|
|
* Defaults to false. Set true if the path being published is shared among
|
|
* different extensions.
|
|
* @return string the published URL for the file or directory. False if the file or directory does not exist.
|
|
*/
|
|
public function getPublishedUrl($path,$hashByName=false)
|
|
{
|
|
if(isset($this->_published[$path]))
|
|
return $this->_published[$path];
|
|
if(($path=realpath($path))!==false)
|
|
{
|
|
if(is_file($path))
|
|
return $this->getBaseUrl().'/'.$this->hash($hashByName ? basename($path) : dirname($path)).'/'.basename($path);
|
|
else
|
|
return $this->getBaseUrl().'/'.$this->hash($hashByName ? basename($path) : $path);
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Generate a CRC32 hash for the directory path. Collisions are higher
|
|
* than MD5 but generates a much smaller hash string.
|
|
* @param string string to be hashed.
|
|
* @return string hashed string.
|
|
*/
|
|
protected function hash($path)
|
|
{
|
|
return sprintf('%x',crc32($path.Yii::getVersion()));
|
|
}
|
|
}
|