391 lines
10 KiB
PHP
Executable File
391 lines
10 KiB
PHP
Executable File
<?php
|
|
/**
|
|
* Phergie
|
|
*
|
|
* PHP version 5
|
|
*
|
|
* LICENSE
|
|
*
|
|
* This source file is subject to the new BSD license that is bundled
|
|
* with this package in the file LICENSE.
|
|
* It is also available through the world-wide-web at this URL:
|
|
* http://phergie.org/license
|
|
*
|
|
* @category Phergie
|
|
* @package Phergie
|
|
* @author Phergie Development Team <team@phergie.org>
|
|
* @copyright 2008-2010 Phergie Development Team (http://phergie.org)
|
|
* @license http://phergie.org/license New BSD License
|
|
* @link http://pear.phergie.org/package/Phergie
|
|
*/
|
|
|
|
/**
|
|
* Composite class for other components to represent the bot.
|
|
*
|
|
* @category Phergie
|
|
* @package Phergie
|
|
* @author Phergie Development Team <team@phergie.org>
|
|
* @license http://phergie.org/license New BSD License
|
|
* @link http://pear.phergie.org/package/Phergie
|
|
*/
|
|
class Phergie_Bot
|
|
{
|
|
/**
|
|
* Current version of Phergie
|
|
*/
|
|
const VERSION = '2.0.1';
|
|
|
|
/**
|
|
* Current driver instance
|
|
*
|
|
* @var Phergie_Driver_Abstract
|
|
*/
|
|
protected $driver;
|
|
|
|
/**
|
|
* Current configuration instance
|
|
*
|
|
* @var Phergie_Config
|
|
*/
|
|
protected $config;
|
|
|
|
/**
|
|
* Current connection handler instance
|
|
*
|
|
* @var Phergie_Connection_Handler
|
|
*/
|
|
protected $connections;
|
|
|
|
/**
|
|
* Current plugin handler instance
|
|
*
|
|
* @var Phergie_Plugin_Handler
|
|
*/
|
|
protected $plugins;
|
|
|
|
/**
|
|
* Current event handler instance
|
|
*
|
|
* @var Phergie_Event_Handler
|
|
*/
|
|
protected $events;
|
|
|
|
/**
|
|
* Current end-user interface instance
|
|
*
|
|
* @var Phergie_Ui_Abstract
|
|
*/
|
|
protected $ui;
|
|
|
|
/**
|
|
* Current processor instance
|
|
*
|
|
* @var Phergie_Process_Abstract
|
|
*/
|
|
protected $processor;
|
|
|
|
/**
|
|
* Returns a driver instance, creating one of the default class if
|
|
* none has been set.
|
|
*
|
|
* @return Phergie_Driver_Abstract
|
|
*/
|
|
public function getDriver()
|
|
{
|
|
if (empty($this->driver)) {
|
|
// Check if a driver has been defined in the configuration to use
|
|
// as the default
|
|
$config = $this->getConfig();
|
|
if (isset($config['driver'])) {
|
|
$class = 'Phergie_Driver_' . ucfirst($config['driver']);
|
|
} else {
|
|
// Otherwise default to the Streams driver.
|
|
$class = 'Phergie_Driver_Streams';
|
|
}
|
|
|
|
$this->driver = new $class;
|
|
}
|
|
return $this->driver;
|
|
}
|
|
|
|
/**
|
|
* Sets the driver instance to use.
|
|
*
|
|
* @param Phergie_Driver_Abstract $driver Driver instance
|
|
*
|
|
* @return Phergie_Bot Provides a fluent interface
|
|
*/
|
|
public function setDriver(Phergie_Driver_Abstract $driver)
|
|
{
|
|
$this->driver = $driver;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sets the configuration to use.
|
|
*
|
|
* @param Phergie_Config $config Configuration instance
|
|
*
|
|
* @return Phergie_Runner_Abstract Provides a fluent interface
|
|
*/
|
|
public function setConfig(Phergie_Config $config)
|
|
{
|
|
$this->config = $config;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns the entire configuration in use or the value of a specific
|
|
* configuration setting.
|
|
*
|
|
* @param string $index Optional index of a specific configuration
|
|
* setting for which the corresponding value should be returned
|
|
* @param mixed $default Value to return if no match is found for $index
|
|
*
|
|
* @return mixed Value corresponding to $index or the entire
|
|
* configuration if $index is not specified
|
|
*/
|
|
public function getConfig($index = null, $default = null)
|
|
{
|
|
if (empty($this->config)) {
|
|
$this->config = new Phergie_Config;
|
|
$this->config->read('Settings.php');
|
|
}
|
|
if ($index !== null) {
|
|
if (isset($this->config[$index])) {
|
|
return $this->config[$index];
|
|
} else {
|
|
return $default;
|
|
}
|
|
}
|
|
return $this->config;
|
|
}
|
|
|
|
/**
|
|
* Returns a plugin handler instance, creating it if it does not already
|
|
* exist and using a default class if none has been set.
|
|
*
|
|
* @return Phergie_Plugin_Handler
|
|
*/
|
|
public function getPluginHandler()
|
|
{
|
|
if (empty($this->plugins)) {
|
|
$this->plugins = new Phergie_Plugin_Handler(
|
|
$this->getConfig(),
|
|
$this->getEventHandler()
|
|
);
|
|
}
|
|
return $this->plugins;
|
|
}
|
|
|
|
/**
|
|
* Sets the plugin handler instance to use.
|
|
*
|
|
* @param Phergie_Plugin_Handler $handler Plugin handler instance
|
|
*
|
|
* @return Phergie_Bot Provides a fluent interface
|
|
*/
|
|
public function setPluginHandler(Phergie_Plugin_Handler $handler)
|
|
{
|
|
$this->plugins = $handler;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns an event handler instance, creating it if it does not already
|
|
* exist and using a default class if none has been set.
|
|
*
|
|
* @return Phergie_Event_Handler
|
|
*/
|
|
public function getEventHandler()
|
|
{
|
|
if (empty($this->events)) {
|
|
$this->events = new Phergie_Event_Handler;
|
|
}
|
|
return $this->events;
|
|
}
|
|
|
|
/**
|
|
* Sets the event handler instance to use.
|
|
*
|
|
* @param Phergie_Event_Handler $handler Event handler instance
|
|
*
|
|
* @return Phergie_Bot Provides a fluent interface
|
|
*/
|
|
public function setEventHandler(Phergie_Event_Handler $handler)
|
|
{
|
|
$this->events = $handler;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns a connection handler instance, creating it if it does not
|
|
* already exist and using a default class if none has been set.
|
|
*
|
|
* @return Phergie_Connection_Handler
|
|
*/
|
|
public function getConnectionHandler()
|
|
{
|
|
if (empty($this->connections)) {
|
|
$this->connections = new Phergie_Connection_Handler;
|
|
}
|
|
return $this->connections;
|
|
}
|
|
|
|
/**
|
|
* Sets the connection handler instance to use.
|
|
*
|
|
* @param Phergie_Connection_Handler $handler Connection handler instance
|
|
*
|
|
* @return Phergie_Bot Provides a fluent interface
|
|
*/
|
|
public function setConnectionHandler(Phergie_Connection_Handler $handler)
|
|
{
|
|
$this->connections = $handler;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns an end-user interface instance, creating it if it does not
|
|
* already exist and using a default class if none has been set.
|
|
*
|
|
* @return Phergie_Ui_Abstract
|
|
*/
|
|
public function getUi()
|
|
{
|
|
if (empty($this->ui)) {
|
|
$this->ui = new Phergie_Ui_Console;
|
|
}
|
|
return $this->ui;
|
|
}
|
|
|
|
/**
|
|
* Sets the end-user interface instance to use.
|
|
*
|
|
* @param Phergie_Ui_Abstract $ui End-user interface instance
|
|
*
|
|
* @return Phergie_Bot Provides a fluent interface
|
|
*/
|
|
public function setUi(Phergie_Ui_Abstract $ui)
|
|
{
|
|
$this->ui = $ui;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns a processer instance, creating one if none exists.
|
|
*
|
|
* @return Phergie_Process_Abstract
|
|
*/
|
|
public function getProcessor()
|
|
{
|
|
if (empty($this->processor)) {
|
|
$class = 'Phergie_Process_Standard';
|
|
|
|
$type = $this->getConfig('processor');
|
|
if (!empty($type)) {
|
|
$class = 'Phergie_Process_' . ucfirst($type);
|
|
}
|
|
|
|
$this->processor = new $class(
|
|
$this,
|
|
$this->getConfig('processor.options', array())
|
|
);
|
|
}
|
|
return $this->processor;
|
|
}
|
|
|
|
/**
|
|
* Sets the processer instance to use.
|
|
*
|
|
* @param Phergie_Process_Abstract $processor Processer instance
|
|
*
|
|
* @return Phergie_Bot Provides a fluent interface
|
|
*/
|
|
public function setProcessor(Phergie_Process_Abstract $processor)
|
|
{
|
|
$this->processor = $processor;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Loads plugins into the plugin handler.
|
|
*
|
|
* @return void
|
|
*/
|
|
protected function loadPlugins()
|
|
{
|
|
$config = $this->getConfig();
|
|
$plugins = $this->getPluginHandler();
|
|
$ui = $this->getUi();
|
|
|
|
$plugins->setAutoload($config['plugins.autoload']);
|
|
foreach ($config['plugins'] as $name) {
|
|
try {
|
|
$plugin = $plugins->addPlugin($name);
|
|
$ui->onPluginLoad($name);
|
|
} catch (Phergie_Plugin_Exception $e) {
|
|
$ui->onPluginFailure($name, $e->getMessage());
|
|
if (!empty($plugin)) {
|
|
$plugins->removePlugin($plugin);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Configures and establishes connections to IRC servers.
|
|
*
|
|
* @return void
|
|
*/
|
|
protected function loadConnections()
|
|
{
|
|
$config = $this->getConfig();
|
|
$driver = $this->getDriver();
|
|
$connections = $this->getConnectionHandler();
|
|
$plugins = $this->getPluginHandler();
|
|
$ui = $this->getUi();
|
|
|
|
foreach ($config['connections'] as $data) {
|
|
$connection = new Phergie_Connection($data);
|
|
$connections->addConnection($connection);
|
|
|
|
$ui->onConnect($data['host']);
|
|
$driver->setConnection($connection)->doConnect();
|
|
$plugins->setConnection($connection);
|
|
$plugins->onConnect();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Establishes server connections and initiates an execution loop to
|
|
* continuously receive and process events.
|
|
*
|
|
* @return Phergie_Bot Provides a fluent interface
|
|
*/
|
|
public function run()
|
|
{
|
|
set_time_limit(0);
|
|
|
|
$timezone = $this->getConfig('timezone', 'UTC');
|
|
date_default_timezone_set($timezone);
|
|
|
|
$ui = $this->getUi();
|
|
$ui->setEnabled($this->getConfig('ui.enabled'));
|
|
|
|
$this->loadPlugins();
|
|
$this->loadConnections();
|
|
|
|
$processor = $this->getProcessor();
|
|
|
|
$connections = $this->getConnectionHandler();
|
|
while (count($connections)) {
|
|
$processor->handleEvents();
|
|
}
|
|
|
|
$ui->onShutdown();
|
|
|
|
return $this;
|
|
}
|
|
}
|