public function start()
{
$this->onStart();
$this->base = event_base_new();
if ($this->_server) {
$this->event = event_new();
event_set($this->event, $this->_server, EV_READ | EV_PERSIST, array($this, 'accept'), $this->base);
event_base_set($this->event, $this->base);
event_add($this->event);
}
if ($this->_service) {
$this->service_event = event_new();
event_set($this->service_event, $this->_service, EV_READ | EV_PERSIST, array($this, 'service'), $this->base);
event_base_set($this->service_event, $this->base);
event_add($this->service_event);
}
if ($this->_master) {
$this->master_event = event_new();
event_set($this->master_event, $this->_master, EV_READ | EV_PERSIST | EV_WRITE, array($this, 'master'), $this->base);
event_base_set($this->master_event, $this->base);
event_add($this->master_event);
}
if ($this->timer) {
$timer = event_timer_new();
event_timer_set($timer, array($this, '_onTimer'), $timer);
event_base_set($timer, $this->base);
//event_timer_pending($timer, $this->timer * 1000000);
event_timer_add($timer, $this->timer * 1000000);
}
event_base_loop($this->base);
}
public function start()
{
$this->base = event_base_new();
if ($this->_server) {
$this->event = event_new();
event_set($this->event, $this->_server, EV_READ | EV_PERSIST, array($this, 'accept'), $this->base);
event_base_set($this->event, $this->base);
event_add($this->event);
}
foreach ($this->_services as $serviceId => $service) {
$event = event_new();
event_set($event, $service, EV_READ | EV_PERSIST | EV_WRITE, array($this, 'service'), $this->base);
event_base_set($event, $this->base);
event_add($event);
$this->events[$serviceId] = $event;
}
if ($this->timer) {
$timer = event_timer_new();
event_timer_set($timer, array($this, '_onTimer'), $timer);
event_base_set($timer, $this->base);
//event_timer_pending($timer, $this->timer * 1000000);
event_timer_add($timer, $this->timer * 1000000);
}
event_base_loop($this->base);
}
/**
* Initialize a new stream listener
*/
public function __construct($fn, $interval)
{
$this->fn = $fn;
$this->interval = $interval;
$this->event = event_timer_new();
event_timer_set($this->event, array($this, 'tick'));
Loop::attachEvent($this->event, $this->interval * 1000);
}
public function setTimeout($callback, $interval_ms)
{
$base = \Event\Emitter::getBase();
$event = event_timer_new();
$arg = array($callback, $event, $interval_ms);
event_timer_set($event, array($this, 'ev_timer'), $arg);
event_base_set($event, $base);
event_add($event, $interval_ms * 1000);
}
/**
* {@inheritdoc}
*/
public function start(Timer $timer)
{
if (!isset($this->timers[$timer])) {
$event = event_new();
event_timer_set($event, $this->callback, $timer);
event_base_set($event, $this->base);
$this->timers[$timer] = $event;
event_add($event, $timer->getInterval() * self::MICROSEC_PER_SEC);
}
}
public function __construct($cb, $timeout = null, $id = null, $priority = null)
{
if ($id === null) {
$id = ++self::$counter;
}
$this->id = $id;
$this->cb = $cb;
$this->ev = event_timer_new();
$timer = $this;
event_timer_set($this->ev, array($this, 'eventCall'));
event_base_set($this->ev, Daemon::$process->eventBase);
if ($priority !== null) {
$this->setPriority($priority);
}
if ($timeout !== null) {
$this->timeout($timeout);
}
Timer::$list[$id] = $this;
}
/**
* Prepares the event to be used
*
* @see event_timer_set
* @link undocumented function
*
* @see event_base_set
* @link http://www.php.net/manual/en/function.event-base-set.php
*
* @param callable $callback Callback function to be called when the matching event occurs.
* @param array $arguments
* @param bool $persist
*
* @throws EventException|\InvalidArgumentException
*
* @return self
*/
public function prepare($callback, array $arguments = array(), $persist = false)
{
if ($this->enabled) {
$this->disable();
}
if (!is_callable($callback)) {
throw new \InvalidArgumentException('Callback must be callable.');
}
if (false === event_base_set($this->resource, $this->base->getResource())) {
throw $this->exception('Could not set event base (event_base_set).');
}
$this->arguments = $arguments;
$this->callback = $callback;
$this->persist = (bool) $persist;
$this->prepared = true;
$this->base->registerEvent($this);
event_timer_set($this->resource, array($this, 'onTimer'));
return $this;
}
function afterFork()
{
$this->initialize();
foreach ($this->watchers as $watcherId => $watcher) {
$eventResource = event_new();
$watcher->eventResource = $eventResource;
switch ($watcher->type) {
case self::$TYPE_STREAM:
$wrapper = $this->wrapStreamCallback($watcher);
event_set($eventResource, $watcher->stream, $watcher->streamFlags, $wrapper);
break;
case self::$TYPE_ONCE:
$wrapper = $this->wrapOnceCallback($watcher);
event_timer_set($eventResource, $wrapper);
break;
case self::$TYPE_REPEATING:
$wrapper = $this->wrapRepeatingCallback($watcher);
event_timer_set($eventResource, $wrapper);
break;
}
$watcher->wrapper = $wrapper;
event_base_set($eventResource, $this->base);
if ($watcher->isEnabled) {
event_add($eventResource, $watcher->interval);
}
}
}
/**
* Schedule a timer for execution.
*
* @param TimerInterface $timer
*/
private function scheduleTimer(TimerInterface $timer)
{
$this->timerEvents[$timer] = $event = event_timer_new();
event_timer_set($event, $this->timerCallback, $timer);
event_base_set($event, $this->eventBase);
event_add($event, $timer->getInterval() * self::MICROSECONDS_PER_SECOND);
}
/**
* {@inheritDoc}
*/
public function repeat(callable $callback, $msInterval, array $options = [])
{
assert($msInterval >= 0, "\$msInterval at Argument 2 expects integer >= 0");
$msInterval *= 1000;
if (isset($options["ms_delay"])) {
$msDelay = (int) $options["ms_delay"];
assert($msDelay >= 0, "ms_delay option expects integer >= 0");
$msDelay *= 1000;
} else {
$msDelay = $msInterval;
}
$watcher = $this->initWatcher(Watcher::TIMER_REPEAT, $callback, $options);
$watcher->msInterval = (int) $msInterval;
\event_timer_set($watcher->eventResource, $this->wrapCallback($watcher));
\event_base_set($watcher->eventResource, $watcher->eventBase);
if ($watcher->isEnabled) {
\event_add($watcher->eventResource, $msDelay);
}
return $watcher->id;
}
protected function addTimerInternal($interval, $callback, $periodic = false)
{
if ($interval < self::MIN_TIMER_RESOLUTION) {
throw new \InvalidArgumentException('Timer events do not support sub-millisecond timeouts.');
}
if (!is_callable($callback)) {
throw new \InvalidArgumentException('The callback must be a callable object.');
}
$timer = (object) array('loop' => $this, 'resource' => $resource = event_new(), 'callback' => $callback, 'interval' => $interval * 1000000, 'periodic' => $periodic, 'cancelled' => false);
$timer->signature = spl_object_hash($timer);
$that = $this;
$callback = function () use($timer, $that, &$callback) {
if ($timer->cancelled === false) {
call_user_func($timer->callback, $timer->signature, $timer->loop);
if ($timer->periodic === true && $timer->cancelled === false) {
event_add($timer->resource, $timer->interval);
} else {
$that->cancelTimer($timer->signature);
}
}
};
event_timer_set($resource, $callback);
event_base_set($resource, $this->base);
event_add($resource, $interval * 1000000);
$this->timers[$timer->signature] = $timer;
return $timer->signature;
}
protected function addTimerInternal($interval, $callback, $periodic = false)
{
if ($interval < self::MIN_TIMER_RESOLUTION) {
throw new \InvalidArgumentException('Timer events do not support sub-millisecond timeouts.');
}
$timer = new Timer($this, $interval, $callback, $periodic);
$resource = event_new();
$timers = $this->timers;
$timers->attach($timer, $resource);
$callback = function () use($timers, $timer, &$callback) {
if (isset($timers[$timer])) {
call_user_func($timer->getCallback(), $timer);
if ($timer->isPeriodic() && isset($timers[$timer])) {
event_add($timers[$timer], $timer->getInterval() * 1000000);
} else {
$timer->cancel();
}
}
};
event_timer_set($resource, $callback);
event_base_set($resource, $this->base);
event_add($resource, $interval * 1000000);
return $timer;
}
