Class yii\mutex\PgsqlMutex

 public function __call($name, $params)
{
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $object) {
 if ($object->hasMethod($name)) {
 return call_user_func_array([$object, $name], $params);
 }
 }
 throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

 

 public function __clone()
{
 $this->_events = [];
 $this->_eventWildcards = [];
 $this->_behaviors = null;
}

 

 public function __construct($config = [])
{
 if (!empty($config)) {
 Yii::configure($this, $config);
 }
 $this->init();
}

 

 public function __get($name)
{
 $getter = 'get' . $name;
 if (method_exists($this, $getter)) {
 // read property, e.g. getName()
 return $this->$getter();
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canGetProperty($name)) {
 return $behavior->$name;
 }
 }
 if (method_exists($this, 'set' . $name)) {
 throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
 }
 throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

 

 public function __isset($name)
{
 $getter = 'get' . $name;
 if (method_exists($this, $getter)) {
 return $this->$getter() !== null;
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canGetProperty($name)) {
 return $behavior->$name !== null;
 }
 }
 return false;
}

 

 public function __set($name, $value)
{
 $setter = 'set' . $name;
 if (method_exists($this, $setter)) {
 // set property
 $this->$setter($value);
 return;
 } elseif (strncmp($name, 'on ', 3) === 0) {
 // on event: attach event handler
 $this->on(trim(substr($name, 3)), $value);
 return;
 } elseif (strncmp($name, 'as ', 3) === 0) {
 // as behavior: attach behavior
 $name = trim(substr($name, 3));
 if ($value instanceof Behavior) {
 $this->attachBehavior($name, $value);
 } elseif ($value instanceof \Closure) {
 $this->attachBehavior($name, call_user_func($value));
 } elseif (isset($value['__class']) && is_subclass_of($value['__class'], Behavior::class)) {
 $this->attachBehavior($name, Yii::createObject($value));
 } elseif (!isset($value['__class']) && isset($value['class']) && is_subclass_of($value['class'], Behavior::class)) {
 $this->attachBehavior($name, Yii::createObject($value));
 } elseif (is_string($value) && is_subclass_of($value, Behavior::class, true)) {
 $this->attachBehavior($name, Yii::createObject($value));
 } else {
 throw new InvalidConfigException('Class is not of type ' . Behavior::class . ' or its subclasses');
 }
 return;
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canSetProperty($name)) {
 $behavior->$name = $value;
 return;
 }
 }
 if (method_exists($this, 'get' . $name)) {
 throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
 }
 throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

 

 public function __unset($name)
{
 $setter = 'set' . $name;
 if (method_exists($this, $setter)) {
 $this->$setter(null);
 return;
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canSetProperty($name)) {
 $behavior->$name = null;
 return;
 }
 }
 throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

 

 public function acquire($name, $timeout = 0)
{
 if (!in_array($name, $this->_locks, true) && $this->acquireLock($name, $timeout)) {
 $this->_locks[] = $name;
 return true;
 }
 return false;
}

 

 protected function acquireLock($name, $timeout = 0)
{
 list($key1, $key2) = $this->getKeysFromName($name);
 return $this->retryAcquire($timeout, function () use ($key1, $key2) {
 return $this->db->useMaster(function ($db) use ($key1, $key2) {
 /** @var \yii\db\Connection $db */
 return (bool) $db->createCommand(
 'SELECT pg_try_advisory_lock(:key1, :key2)',
 [':key1' => $key1, ':key2' => $key2]
 )->queryScalar();
 });
 });
}

 

 public function attachBehavior($name, $behavior)
{
 $this->ensureBehaviors();
 return $this->attachBehaviorInternal($name, $behavior);
}

 

 public function attachBehaviors($behaviors)
{
 $this->ensureBehaviors();
 foreach ($behaviors as $name => $behavior) {
 $this->attachBehaviorInternal($name, $behavior);
 }
}

 

 public function behaviors()
{
 return [];
}

 

 public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
 if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
 return true;
 } elseif ($checkBehaviors) {
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canGetProperty($name, $checkVars)) {
 return true;
 }
 }
 }
 return false;
}

 

 public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
 if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
 return true;
 } elseif ($checkBehaviors) {
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canSetProperty($name, $checkVars)) {
 return true;
 }
 }
 }
 return false;
}

 

 public static function className()
{
 return get_called_class();
}

 

 public function detachBehavior($name)
{
 $this->ensureBehaviors();
 if (isset($this->_behaviors[$name])) {
 $behavior = $this->_behaviors[$name];
 unset($this->_behaviors[$name]);
 $behavior->detach();
 return $behavior;
 }
 return null;
}

 

 public function detachBehaviors()
{
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $name => $behavior) {
 $this->detachBehavior($name);
 }
}

 

 public function ensureBehaviors()
{
 if ($this->_behaviors === null) {
 $this->_behaviors = [];
 foreach ($this->behaviors() as $name => $behavior) {
 $this->attachBehaviorInternal($name, $behavior);
 }
 }
}

 

 public function getBehavior($name)
{
 $this->ensureBehaviors();
 return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

 

 public function getBehaviors()
{
 $this->ensureBehaviors();
 return $this->_behaviors;
}

 

 public function hasEventHandlers($name)
{
 $this->ensureBehaviors();
 if (!empty($this->_events[$name])) {
 return true;
 }
 foreach ($this->_eventWildcards as $wildcard => $handlers) {
 if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
 return true;
 }
 }
 return Event::hasHandlers($this, $name);
}

 

 public function hasMethod($name, $checkBehaviors = true)
{
 if (method_exists($this, $name)) {
 return true;
 } elseif ($checkBehaviors) {
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->hasMethod($name)) {
 return true;
 }
 }
 }
 return false;
}

 

 public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
 return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

 

 public function init()
{
 parent::init();
 if ($this->db->driverName !== 'pgsql') {
 throw new InvalidConfigException('In order to use PgsqlMutex connection must be configured to use PgSQL database.');
 }
}

 

 public function isAcquired($name)
{
 return in_array($name, $this->_locks, true);
}

 

 public function off($name, $handler = null)
{
 $this->ensureBehaviors();
 if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
 return false;
 }
 if ($handler === null) {
 unset($this->_events[$name], $this->_eventWildcards[$name]);
 return true;
 }
 $removed = false;
 // plain event names
 if (isset($this->_events[$name])) {
 foreach ($this->_events[$name] as $i => $event) {
 if ($event[0] === $handler) {
 unset($this->_events[$name][$i]);
 $removed = true;
 }
 }
 if ($removed) {
 $this->_events[$name] = array_values($this->_events[$name]);
 return true;
 }
 }
 // wildcard event names
 if (isset($this->_eventWildcards[$name])) {
 foreach ($this->_eventWildcards[$name] as $i => $event) {
 if ($event[0] === $handler) {
 unset($this->_eventWildcards[$name][$i]);
 $removed = true;
 }
 }
 if ($removed) {
 $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
 // remove empty wildcards to save future redundant regex checks:
 if (empty($this->_eventWildcards[$name])) {
 unset($this->_eventWildcards[$name]);
 }
 }
 }
 return $removed;
}

 

 public function on($name, $handler, $data = null, $append = true)
{
 $this->ensureBehaviors();
 if (strpos($name, '*') !== false) {
 if ($append || empty($this->_eventWildcards[$name])) {
 $this->_eventWildcards[$name][] = [$handler, $data];
 } else {
 array_unshift($this->_eventWildcards[$name], [$handler, $data]);
 }
 return;
 }
 if ($append || empty($this->_events[$name])) {
 $this->_events[$name][] = [$handler, $data];
 } else {
 array_unshift($this->_events[$name], [$handler, $data]);
 }
}

 

 public function release($name)
{
 if ($this->releaseLock($name)) {
 $index = array_search($name, $this->_locks);
 if ($index !== false) {
 unset($this->_locks[$index]);
 }
 return true;
 }
 return false;
}

 

 protected function releaseLock($name)
{
 list($key1, $key2) = $this->getKeysFromName($name);
 return $this->db->useMaster(function ($db) use ($key1, $key2) {
 /** @var \yii\db\Connection $db */
 return (bool) $db->createCommand(
 'SELECT pg_advisory_unlock(:key1, :key2)',
 [':key1' => $key1, ':key2' => $key2]
 )->queryScalar();
 });
}

 

 public function trigger($name, ?Event $event = null)
{
 $this->ensureBehaviors();
 $eventHandlers = [];
 foreach ($this->_eventWildcards as $wildcard => $handlers) {
 if (StringHelper::matchWildcard($wildcard, $name)) {
 $eventHandlers[] = $handlers;
 }
 }
 if (!empty($this->_events[$name])) {
 $eventHandlers[] = $this->_events[$name];
 }
 if (!empty($eventHandlers)) {
 $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
 if ($event === null) {
 $event = new Event();
 }
 if ($event->sender === null) {
 $event->sender = $this;
 }
 $event->handled = false;
 $event->name = $name;
 foreach ($eventHandlers as $handler) {
 $event->data = $handler[1];
 call_user_func($handler[0], $event);
 // stop further handling if the event is handled
 if ($event->handled) {
 return;
 }
 }
 }
 // invoke class-level attached handlers
 Event::trigger($this, $name, $event);
}