/**
* Create a new cached image.
*
*/
public function __construct($source = null, $args = null)
{
parent::__construct(array(), false);
$this->ID = -1;
$this->Filename = CloudAssets::config()->missing_image;
$this->source = $source;
if (empty($args)) {
$this->dimensions = '100x100';
} else {
switch ($args[0]) {
case 'SetWidth':
case 'SetHeight':
$this->dimensions = $args[1] . 'x' . $args[1];
break;
case 'SetSize':
case 'SetRatioSize':
case 'ResizedImage':
case 'CroppedImage':
case 'PaddedImage':
$this->dimensions = $args[1] . 'x' . $args[2];
break;
default:
$this->dimensions = '100x100';
}
}
}
public function setUp()
{
parent::setUp();
Config::inst()->update('CloudAssets', 'disabled', false);
Config::inst()->update('CloudAssets', 'uploads_disabled', false);
Config::inst()->update('Director', 'alternate_protocol', 'http');
if (!file_exists(ASSETS_PATH)) {
mkdir(ASSETS_PATH);
}
/* Create a test folders for each of the fixture references */
$folderIDs = $this->allFixtureIDs('Folder');
foreach ($folderIDs as $folderID) {
$folder = DataObject::get_by_id('Folder', $folderID);
if (!file_exists(BASE_PATH . "/{$folder->Filename}")) {
mkdir(BASE_PATH . "/{$folder->Filename}");
}
}
/* Create a test files for each of the fixture references */
$fileIDs = $this->allFixtureIDs('File');
foreach ($fileIDs as $fileID) {
if ($fileID == 'png') {
continue;
}
$file = DataObject::get_by_id('File', $fileID);
$fh = fopen(BASE_PATH . "/{$file->Filename}", "w");
fwrite($fh, str_repeat('x', 1000));
fclose($fh);
}
// Conditional fixture creation in case the 'cms' module is installed
if (class_exists('ErrorPage')) {
$page = new ErrorPage(array('Title' => 'Page not Found', 'ErrorCode' => 404));
$page->write();
$page->publish('Stage', 'Live');
}
$src = dirname(__FILE__) . '/test-png32.png';
$dest = ASSETS_PATH . '/FileTest-folder1/test-png32.png';
$f = copy($src, $dest);
if (!$f) {
die('unable to copy $src to $dest');
}
CloudAssets::inst()->clearBucketCache();
}
function setUp()
{
$this->bucket = CloudAssets::inst()->map('assets/Uploads/CloudAssetsS3Test.txt');
parent::setUpOnce();
}
/**
* If the file is present in the database and the cloud but not
* locally, create a placeholder for it. This can happen in a lot
* of cases such as load balanced servers and local development.
*/
public function createLocalIfNeeded()
{
if ($this->owner->CloudStatus === 'Live') {
$bucket = $this->getCloudBucket();
if ($bucket && $bucket->isLocalCopyEnabled()) {
if (!file_exists($this->owner->getFullPath()) || $this->containsPlaceholder()) {
try {
$this->downloadFromCloud();
} catch (Exception $e) {
// I'm not sure what the correct behaviour is here
// Pretty sure it'd be better to have a broken image
// link than a 500 error though.
CloudAssets::inst()->getLogger()->error("CloudAssets: Failed bucket download: " . $e->getMessage() . " for " . $this->owner->getFullPath());
}
}
} else {
if (!file_exists($this->owner->getFullPath())) {
$this->convertToPlaceholder();
}
}
}
}
/**
* Return an image object representing the image in the given format.
* This image will be generated using generateFormattedImage().
* The generated image is cached, to flush the cache append ?flush=1 to your URL.
*
* Just pass the correct number of parameters expected by the working function
*
* @param string $format The name of the format.
* @return CloudImageCached|null
*/
public function getFormattedImage($format)
{
$args = func_get_args();
$logger = CloudAssets::inst()->getLogger();
if ($this->ID && $this->Filename && Director::fileExists($this->Filename)) {
$cacheFile = call_user_func_array(array($this, "cacheFilename"), $args);
$cachePath = Director::baseFolder() . "/" . $cacheFile;
$stored = CloudImageCachedStore::get()->filter('Filename', $cacheFile)->first();
if ($stored && !$stored->exists()) {
$stored = null;
}
// If ?flush is present, always wipe existing data and start clean
if (isset($_GET['flush'])) {
// There was a bug here caused by the fact that GDBackend tries
// to read the size off the cached image, which would be a placeholder
// in certain cases.
// I'm not 100% sure what the correct behaviour is here. For now
// we'll destroy the existing image, causing it to be re-uploaded
// every time. That seems safer if a little bit wasteful.
$logger->debug("CloudAssets: deleting cached image because of flush: {$cachePath}");
if (file_exists($cachePath)) {
unlink($cachePath);
}
// delete the existing meta if it existed
if ($stored) {
$stored->delete();
$stored = null;
}
}
// start building out the record
$cached = new CloudImageCached($cacheFile);
$cached->Title = $this->Title;
$cached->ParentID = $this->ParentID;
// Is there a meta record for this formatted file?
if ($stored) {
// Has it been successfully uploaded to the cloud?
// If so, we can just send this puppy on
// If not, is there a local file that's present and correct?
// If not, we need to wipe the meta and anything local and regenerate
if ($stored->CloudStatus !== 'Live' && $cached->isLocalMissing()) {
$stored->delete();
$stored = null;
if (file_exists($cachePath)) {
unlink($cachePath);
}
} else {
$cached->setStoreRecord($stored);
}
}
// If there is no meta record (or an invalid one), is there a local file or placeholder?
if (!$stored) {
// if the local exists as a placeholder, we need to check if the cloud version is valid
if (file_exists($cachePath) && $cached->containsPlaceholder()) {
try {
$cached->downloadFromCloud();
} catch (Exception $e) {
// We want to fail silently here if there is any trouble
// because we can always regenerate the thumbnail
if (CloudAssets::config()->missing_image) {
return new CloudImageMissing($this, $args);
}
}
}
// If we don't have a valid local version at this point...
if ($cached->isLocalMissing()) {
// delete whatever might have been there
if (file_exists($cachePath)) {
unlink($cachePath);
}
$logger->debug("CloudAssets: generating formatted image at {$cachePath}");
// Regenerate the formatted image
if ($this->CloudStatus === 'Live' && $this->isLocalMissing()) {
try {
$this->downloadFromCloud();
} catch (Exception $e) {
if (CloudAssets::config()->missing_image) {
return new CloudImageMissing($this, $args);
}
}
call_user_func_array(array($this, "generateFormattedImage"), $args);
$this->convertToPlaceholder();
} else {
call_user_func_array(array($this, "generateFormattedImage"), $args);
}
}
// If we now have a valid image, generate a stored meta record for it
if (file_exists($cachePath)) {
$stored = new CloudImageCachedStore();
$stored->Filename = $cacheFile;
$stored->SourceID = $this->ID;
$stored->write();
// all the other fields will get set when the cloud status is updated
$cached->setStoreRecord($stored);
}
}
// upload to cloud if needed
$cached->updateCloudStatus();
return $cached;
}
}
