DefaultLockHandler.php

<?php
/**
 * wCMF - wemove Content Management Framework
 * Copyright (C) 2005-2020 wemove digital solutions GmbH
 *
 * Licensed under the terms of the MIT License.
 *
 * See the LICENSE file distributed with this work for
 * additional information.
 */
namespace wcmf\lib\persistence\concurrency\impl;
 
use wcmf\lib\core\LogManager;
use wcmf\lib\core\Session;
use wcmf\lib\model\ObjectQuery;
use wcmf\lib\persistence\BuildDepth;
use wcmf\lib\persistence\concurrency\Lock;
use wcmf\lib\persistence\concurrency\LockHandler;
use wcmf\lib\persistence\concurrency\PessimisticLockException;
use wcmf\lib\persistence\Criteria;
use wcmf\lib\persistence\ObjectId;
use wcmf\lib\persistence\PersistenceFacade;
use wcmf\lib\persistence\PersistentObject;
 
/**
 * DefaultLockHandler implements the LockHandler interface for relational
 * databases. It relies on an entity type that implements the PersistentLock
 * interface.
 *
 * @author ingo herwig <ingo@wemove.com>
 */
class DefaultLockHandler implements LockHandler {
 
  const SESSION_VARNAME = 'DefaultLockHandler.locks';
 
  private $persistenceFacade = null;
  private $session = null;
  private $lockType = null;
 
  private static $logger = null;
 
  /**
   * Constructor
   * @param $persistenceFacade
   * @param $session
   * @param $lockType Entity type name of PersistentLock instances
   */
  public function __construct(PersistenceFacade $persistenceFacade,
          Session $session,
          $lockType) {
    $this->persistenceFacade = $persistenceFacade;
    $this->session = $session;
    $this->lockType = $lockType;
    if (self::$logger == null) {
      self::$logger = LogManager::getLogger(__CLASS__);
    }
  }
 
  /**
   * @see LockHandler::aquireLock()
   */
  public function aquireLock(ObjectId $oid, $type, PersistentObject $currentState=null) {
    $authUserLogin = $this->getAuthUser();
 
    // check for existing locks
    $lock = $this->getLock($oid);
    if ($lock != null) {
      if ($lock->getType() == Lock::TYPE_PESSIMISTIC) {
        // if the existing lock is a pessimistic lock and it is owned by another
        // user, we throw an exception
        if ($lock->getLogin() != $authUserLogin) {
          throw new PessimisticLockException($lock);
        }
        // if the existing lock is a pessimistic lock and is owned by the user
        // there is no need to aquire a optimistic lock
        if ($type == Lock::TYPE_OPTIMISTIC) {
          return;
        }
      }
    }
 
    // create the lock instance
    $lock = new Lock($type, $oid, $authUserLogin);
 
    // set the current state for optimistic locks
    if ($type == Lock::TYPE_OPTIMISTIC) {
      $lock->setCurrentState($currentState);
    }
 
    // store the lock
    $this->storeLock($lock);
  }
 
  /**
   * @see LockHandler::releaseLock()
   */
  public function releaseLock(ObjectId $oid, $type=null) {
    $authUserLogin = $this->getAuthUser();
 
    // delete locks for the given oid and current user
    $query = new ObjectQuery($this->lockType, __CLASS__.__METHOD__);
    $tpl = $query->getObjectTemplate($this->lockType);
    $tpl->setValue('objectid', Criteria::asValue("=", $oid));
    $tpl->setValue('login', Criteria::asValue("=", $authUserLogin));
    $locks = $query->execute(BuildDepth::SINGLE);
    foreach($locks as $lock) {
      // delete lock immediatly
      $lock->getMapper()->delete($lock);
      $this->removeSessionLock($oid, $type);
    }
  }
 
  /**
   * @see LockHandler::releaseLocks()
   */
  public function releaseLocks(ObjectId $oid) {
    // delete locks for the given oid
    $query = new ObjectQuery($this->lockType, __CLASS__.__METHOD__);
    $tpl = $query->getObjectTemplate($this->lockType);
    $tpl->setValue('objectid', Criteria::asValue("=", $oid));
    $locks = $query->execute(BuildDepth::SINGLE);
    foreach($locks as $lock) {
      // delete lock immediatly
      $lock->getMapper()->delete($lock);
      $this->removeSessionLock($oid);
    }
  }
 
  /**
   * @see LockHandler::releaseAllLocks()
   */
  public function releaseAllLocks() {
    $authUserLogin = $this->getAuthUser();
 
    // delete locks for the current user
    $query = new ObjectQuery($this->lockType, __CLASS__.__METHOD__);
    $tpl = $query->getObjectTemplate($this->lockType);
    $tpl->setValue('login', Criteria::asValue("=", $authUserLogin));
    $locks = $query->execute(BuildDepth::SINGLE);
    foreach($locks as $lock) {
      // delete lock immediatly
      $lock->getMapper()->delete($lock);
    }
    // delete all session locks
    $this->removeSessonLocks();
  }
 
  /**
   * @see LockHandler::getLock()
   */
  public function getLock(ObjectId $oid) {
    // check if a lock is stored in the session (maybe optimistic
    // or pessimistic)
    $locks = $this->getSessionLocks();
    $oidStr = $oid->__toString();
    $sessionLock = null;
    if (isset($locks[$oidStr])) {
      $sessionLock = $locks[$oidStr];
    }
 
    // if the session lock is pessimistic (exclusive), return it
    if ($sessionLock != null && $sessionLock->getType() == Lock::TYPE_PESSIMISTIC) {
      return $sessionLock;
    }
    else {
      // otherwise we need to check for a pessimistic lock in the store
      $query = new ObjectQuery($this->lockType, __CLASS__.__METHOD__);
      $tpl = $query->getObjectTemplate($this->lockType);
      $tpl->setValue('objectid', Criteria::asValue('=', $oid));
      $locks = $query->execute(BuildDepth::SINGLE);
      if (sizeof($locks) > 0) {
        $lockObj = $locks[0];
        $lock = new Lock(Lock::TYPE_PESSIMISTIC, $oid, $lockObj->getValue('login'),
                $lockObj->getValue('created'));
 
        // if the lock belongs to the current user, we store
        // it in the session for later retrieval
        $authUserLogin = $this->getAuthUser();
        if ($lockObj->getValue('login') == $authUserLogin) {
          $this->addSessionLock($lock);
        }
        return $lock;
      }
    }
 
    return $sessionLock;
  }
 
  /**
   * @see LockHandler::updateLock()
   */
  public function updateLock(ObjectId $oid, PersistentObject $object) {
    $lock = $this->getLock($oid);
    if ($lock) {
      if ($lock->getType() == Lock::TYPE_OPTIMISTIC) {
        $authUserLogin = $this->getAuthUser();
        if ($lock->getLogin() == $authUserLogin) {
          $lock->setCurrentState($object);
          $this->storeLock($lock);
        }
      }
    }
  }
 
  /**
   * Store the given Lock instance for later retrieval
   * @param $lock Lock instance
   */
  protected function storeLock(Lock $lock) {
    if ($lock->getType() == Lock::TYPE_PESSIMISTIC) {
      // pessimistic locks must be stored in the database in order
      // to be seen by other users
      $lockObj = $this->persistenceFacade->create($this->lockType, BuildDepth::REQUIRED);
      $lockObj->setValue('objectid', $lock->getObjectId());
      $lockObj->setValue('login', $lock->getLogin());
      $lockObj->setValue('created', $lock->getCreated());
      // save lock immediatly
      $lockObj->getMapper()->save($lockObj);
    }
    // store the lock in the session for faster retrieval
    $this->addSessionLock($lock);
  }
 
  /**
   * Get the login of the current user
   * @return String
   */
  protected function getAuthUser() {
    return $this->session->getAuthUser();
  }
 
  /**
   * Get the Lock instances stored in the session
   * @return Associative array with the serialized ObjectId instances
   * as keys and the Lock instances as values
   */
  protected function getSessionLocks() {
    if ($this->session->exist(self::SESSION_VARNAME)) {
      return $this->session->get(self::SESSION_VARNAME);
    }
    return [];
  }
 
  /**
   * Add a given Lock instance to the session
   * @param $lock Lock instance
   */
  protected function addSessionLock(Lock $lock) {
    $locks = $this->getSessionLocks();
    $locks[$lock->getObjectId()->__toString()] = $lock;
    $this->session->set(self::SESSION_VARNAME, $locks);
  }
 
  /**
   * Remove a given Lock instance from the session
   * @param $oid The locked oid
   * @param $type One of the Lock::Type constants or null for all types (default: _null_)
   */
  protected function removeSessionLock(ObjectId $oid, $type) {
    $locks = $this->getSessionLocks();
    if (isset($locks[$oid->__toString()])) {
      $lock = $locks[$oid->__toString()];
      if ($type == null || $type != null && $lock->getType() == $type) {
        unset($locks[$oid->__toString()]);
        $this->session->set(self::SESSION_VARNAME, $locks);
      }
    }
  }
 
  /**
   * Remove all Lock instances from the session
   */
  protected function removeSessonLocks() {
    $this->session->remove(self::SESSION_VARNAME);
  }
}
?>