Current File : //home1/lightco1/www/lightingrepublic.com.au/administrator/components/com_akeeba/akeeba/factory.php
<?php
/**
* Akeeba Engine
* The modular PHP5 site backup engine
* @copyright Copyright (c)2009-2013 Nicholas K. Dionysopoulos
* @license GNU GPL version 3 or, at your option, any later version
* @package akeebaengine
*
*/
// Protection against direct access
defined('AKEEBAENGINE') or die();
// Define the log levels
if(!defined('_AE_LOG_NONE'))
{
define("_AE_LOG_NONE", 0);
define("_AE_LOG_ERROR", 1);
define("_AE_LOG_WARNING", 2);
define("_AE_LOG_INFO", 3);
define("_AE_LOG_DEBUG", 4);
}
// Try to kill errors display
if( function_exists('ini_set') && !defined('AKEEBADEBUG') ) {
ini_set('display_errors', false);
}
// Set a constant with the cacert.pem path and load the platform helper class first
$platformLoaded = false;
if(defined('AKEEBAROOT')) {
$path = AKEEBAROOT.DIRECTORY_SEPARATOR.'platform'.DIRECTORY_SEPARATOR.'platform.php';
if(file_exists($path) && !defined('AKEEBA_CACERT_PEM')) {
define('AKEEBA_CACERT_PEM', AKEEBAROOT.'/assets/cacert.pem');
require_once AKEEBAROOT.DIRECTORY_SEPARATOR.'platform'.DIRECTORY_SEPARATOR.'platform.php';
$platformLoaded = true;
}
}
if(!$platformLoaded && !defined('AKEEBA_CACERT_PEM')) {
define('AKEEBA_CACERT_PEM',dirname(__FILE__).'/assets/cacert.pem');
require_once dirname(__FILE__).DIRECTORY_SEPARATOR.'platform'.DIRECTORY_SEPARATOR.'platform.php';
}
/**
* The Akeeba Engine Factory class
* This class is reposnsible for instanciating all Akeeba classes
*/
class AEFactory {
/** @var array A list of instanciated objects */
private $objectlist = array();
/** Private constructor makes sure we can't directly instanciate the class */
private function __construct() {}
/**
* Gets a single, internally used instance of the Factory
* @param string $serialized_data [optional] Serialized data to spawn the instance from
* @return AEFactory A reference to the unique Factory object instance
*/
protected static function &getInstance( $serialized_data = null ) {
static $myInstance;
if(!is_object($myInstance) || !is_null($serialized_data))
if(!is_null($serialized_data))
$myInstance = unserialize($serialized_data);
else
$myInstance = new self();
return $myInstance;
}
/**
* Internal function which instanciates a class named $class_name.
* The autoloader
* @param string $class_name
* @return
*/
protected static function &getClassInstance($class_name) {
$self = self::getInstance();
if(!isset($self->objectlist[$class_name]))
{
if(!class_exists($class_name, true)) {
$self->objectlist[$class_name] = false;
} else {
$self->objectlist[$class_name] = new $class_name;
}
}
return $self->objectlist[$class_name];
}
/**
* Internal function which removes a class named $class_name
* @param string $class_name
*/
protected static function unsetClassInstance($class_name) {
$self = self::getInstance();
if(isset($self->objectlist[$class_name]))
{
$self->objectlist[$class_name] = null;
unset($self->objectlist[$class_name]);
}
}
// ========================================================================
// Public factory interface
// ========================================================================
/**
* Gets a serialized snapshot of the Factory for safekeeping (hibernate)
* @return string The serialized snapshot of the Factory
*/
public static function serialize() {
// Call _onSerialize in all classes known to the factory
if(!empty($self->objectlist))
{
foreach($self->objectlist as $class_name => $object)
{
$o = $self->objectlist[$class_name];
if(method_exists($o, '_onSerialize'))
{
call_user_method('_onSerialize', $o);
}
}
}
// Serialize the factory
return serialize(self::getInstance());
}
/**
* Regenerates the full Factory state from a serialized snapshot (resume)
* @param string $serialized_data The serialized snapshot to resume from
*/
public static function unserialize($serialized_data) {
self::getInstance($serialized_data);
}
/**
* Reset the internal factory state, freeing all previosuly created objects
*/
public static function nuke()
{
$self = self::getInstance();
foreach($self->objectlist as $key => $object)
{
$self->objectlist[$key] = null;
}
$self->objectlist = array();
}
// ========================================================================
// Akeeba classes
// ========================================================================
/**
* Returns an Akeeba Configuration object
* @return AEConfiguration The Akeeba Configuration object
*/
public static function &getConfiguration()
{
return self::getClassInstance('AEConfiguration');
}
/**
* Returns a statistics object, used to track current backup's progress
* @return AEUtilStatistics
*/
public static function &getStatistics()
{
return self::getClassInstance('AEUtilStatistics');
}
/**
* Returns the currently configured archiver engine
* @return AEAbstractArchiver
*/
public static function &getArchiverEngine()
{
static $class_name;
if( empty($class_name) )
{
$registry = self::getConfiguration();
$engine = $registry->get('akeeba.advanced.archiver_engine');
$class_name = 'AEArchiver'.ucfirst($engine);
}
return self::getClassInstance($class_name);
}
/**
* Returns the currently configured dump engine
* @return AEAbstractDump
*/
public static function &getDumpEngine($reset = false)
{
static $class_name;
if( empty($class_name) )
{
$registry = self::getConfiguration();
$engine = $registry->get('akeeba.advanced.dump_engine');
$class_name = 'AEDump'.ucfirst($engine);
}
if($reset) self::unsetClassInstance($class_name);
return self::getClassInstance($class_name);
}
/**
* Returns the filesystem scanner engine instance
* @return AEAbstractScan The scanner engine
*/
public static function &getScanEngine()
{
static $class_name;
if( empty($class_name) )
{
$registry = self::getConfiguration();
$engine = $registry->get('akeeba.advanced.scan_engine');
$class_name = 'AEScan'.ucfirst($engine);
}
return self::getClassInstance($class_name);
}
public static function &getWriterEngine()
{
// @todo Implement AEFactory::getWriterEngine();
}
/**
* Returns the currently post-processing engine
* @return AEAbstractPostproc
*/
public static function &getPostprocEngine($myClass = null)
{
if(!empty($myClass)) {
return self::getClassInstance('AEPostproc'.ucfirst($myClass));
}
static $class_name;
if( empty($class_name) )
{
$registry = self::getConfiguration();
$engine = $registry->get('akeeba.advanced.proc_engine');
$class_name = 'AEPostproc'.ucfirst($engine);
}
return self::getClassInstance($class_name);
}
/**
* Returns an instance of the Filters feature class
* @return AECoreFilters The Filters feature class' object instance
*/
public static function &getFilters()
{
return self::getClassInstance('AECoreFilters');
}
/**
* Returns an instance of the specified filter group class. Do note that it does not
* work with platform filter classes. They are handled internally by AECoreFilters.
* @param string $filter_name The filter class to load, without AEFilter prefix
* @return AEAbstractFilter The filter class' object instance
*/
public static function &getFilterObject($filter_name)
{
return self::getClassInstance('AEFilter'.ucfirst($filter_name));
}
/**
* Loads an engine domain class and returns its associated object
* @param string $domain_name The name of the domain, e.g. installer for AECoreDomainInstaller
* @return AEAbstractPart
*/
public static function &getDomainObject($domain_name)
{
return self::getClassInstance('AECoreDomain'.ucfirst($domain_name));
}
/**
* Returns a database connection object. It's an alias of AECoreDatabase::getDatabase()
* @param array $options Options to use when instanciating the database connection
* @return AEAbstractDriver
*/
public static function &getDatabase($options = null)
{
if(is_null($options))
{
$options = AEPlatform::getInstance()->get_platform_database_options();
}
return AECoreDatabase::getDatabase($options);
}
/**
* Returns a database connection object. It's an alias of AECoreDatabase::getDatabase()
* @param array $options Options to use when instanciating the database connection
* @return AEAbstractDriver
*/
public static function unsetDatabase($options = null)
{
if(is_null($options))
{
$options = AEPlatform::getInstance()->get_platform_database_options();
}
$db = AECoreDatabase::getDatabase($options);
$db->close();
AECoreDatabase::unsetDatabase($options);
}
/**
* Get the a reference to the Akeeba Engine's timer
* @return AECoreTimer
*/
public static function &getTimer()
{
return self::getClassInstance('AECoreTimer');
}
/**
* Get a reference to Akeeba Engine's heart, Kettenrad
* @return AECoreKettenrad
*/
public static function &getKettenrad()
{
return self::getClassInstance('AECoreKettenrad');
}
// ========================================================================
// Handy functions
// ========================================================================
public static function getAkeebaRoot()
{
static $root = null;
if(empty($root)) {
if(defined('AKEEBAROOT')) {
$root = AKEEBAROOT;
} else {
$root = dirname(__FILE__);
}
}
return $root;
}
}
// Make sure the class autoloader is loaded
if(defined('AKEEBAROOT')) {
require_once AKEEBAROOT.DIRECTORY_SEPARATOR.'autoloader.php';
require_once AKEEBAROOT.DIRECTORY_SEPARATOR.'platform'.DIRECTORY_SEPARATOR.'platform.php';
} else {
require_once dirname(__FILE__).DIRECTORY_SEPARATOR.'autoloader.php';
require_once dirname(__FILE__).DIRECTORY_SEPARATOR.'platform'.DIRECTORY_SEPARATOR.'platform.php';
}
// Try to register AEAutoloader with SPL, or fall back to making use of JLoader
// Obviously, performance is better with SPL, but not all systems support it.
if( function_exists('spl_autoload_register') ) {
// Joomla! is using its own autoloader function which has to be registered first...
if(function_exists('__autoload')) spl_autoload_register('__autoload');
// ...and then register ourselves.
spl_autoload_register('AEAutoloader');
} else {
// Guys, it's 2011 at the time of this writing. If you have a host which
// doesn't support SPL yet, SWITCH HOSTS!
throw new Exception('Akeeba Backup REQUIRES the SPL extension to be loaded and activated',500);
}
// Define and register the timeout trap
function AkeebaTimeoutTrap()
{
if( connection_status() >= 2 ) {
AEUtilLogger::WriteLog(_AE_LOG_ERROR, 'Akeeba Engine has timed out' );
}
}
register_shutdown_function("AkeebaTimeoutTrap");
Mini Shell