class.RemoteCapablePersistenceFacadeImpl.php

Go to the documentation of this file.

<?php
/**
 * wCMF - wemove Content Management Framework
 * Copyright (C) 2005-2010 wemove digital solutions GmbH
 *
 * Licensed under the terms of any of the following licenses 
 * at your choice:
 *
 * - GNU Lesser General Public License (LGPL)
 *   http://www.gnu.org/licenses/lgpl.html
 * - Eclipse Public License (EPL)
 *   http://www.eclipse.org/org/documents/epl-v10.php
 *
 * See the license.txt file distributed with this work for 
 * additional information.
 *
 * $Id$
 */
require_once(BASE."wcmf/lib/persistence/class.PersistenceFacadeImpl.php");
require_once(BASE."wcmf/lib/remoting/class.RemotingFacade.php");

/**
 * @class RemoteCapablePersistenceFacade
 * @ingroup Persistence
 * @brief RemoteCapablePersistenceFacade delegates local persistence operations to the 
 * default PersistenceFacadeImpl and remote operations to a remote server.
 *
 * @author ingo herwig <ingo@wemove.com>
 */
class RemoteCapablePersistenceFacadeImpl extends PersistenceFacadeImpl
{
  // constants
  const PROXY_OBJECTS_SESSION_VARNAME = 'RemoteCapablePersistenceFacadeImpl.proxyObjects';
  const REMOTE_OBJECTS_SESSION_VARNAME = 'RemoteCapablePersistenceFacadeImpl.remoteObjects';
  
  var $_isResolvingProxies = true;
  var $_isTranslatingValues = true;
  
  /**
   * Constructor
   */
  function RemoteCapablePersistenceFacadeImpl()
  {
    // initialize session variables
    $session = &SessionData::getInstance();
    if (!$session->exist(self::PROXY_OBJECTS_SESSION_VARNAME)) {
      $proxies = array();
      $session->set(self::PROXY_OBJECTS_SESSION_VARNAME, $proxies);
    }
    if (!$session->exist(self::REMOTE_OBJECTS_SESSION_VARNAME)) {
      $objs = array();
      $session->set(self::REMOTE_OBJECTS_SESSION_VARNAME, $objs);
    }
  }
  /**
   * Tell the PersistenceFacade implementation to resolve proxies or not.
   * @param isResolvingProxies True/False whether proxies should be resolved or not
   */
  function setResolveProxies($isResolvingProxies)
  {
    $this->_isResolvingProxies = $isResolvingProxies;
  }
  /**
   * Check if the PersistenceFacade implementation is resolving proxies or not.
   * @return True/False whether proxies are resolved or not
   */
  function isResolvingProxies()
  {
    return $this->_isResolvingProxies;
  }
  /**
   * Tell the PersistenceFacade implementation to translate remote values or not.
   * @param isTranslatingValues True/False whether values should be translated or not
   */
  function setTranslatingValues($isTranslatingValues)
  {
    $this->_isTranslatingValues = $isTranslatingValues;
  }
  /**
   * Check if the PersistenceFacade implementation is translating remote values or not.
   * @return True/False whether values are tanslated or not
   */
  function isTranslatingValues()
  {
    return $this->_isTranslatingValues;
  }
  /**
   * @see PersistenceFacade::load()
   */
  function &load($oid, $buildDepth, $buildAttribs=null, $buildTypes=null)
  {
    if ($this->isResolvingProxies() && strlen(PersistenceFacade::getOIDParameter($oid, 'prefix')) > 0) {
      // load real subject
      $obj = $this->loadRemoteObject($oid, $buildDepth);
    }
    else
    {
      $obj = &parent::load($oid, $buildDepth, $buildAttribs, $buildTypes);
      if ($obj && $this->isResolvingProxies() && strlen($umi = $obj->getValue('umi')) > 0) {
        // store proxy for later reference
        $this->registerProxyObject($umi, $obj, $buildDepth);
        // load real subject
        $obj = $this->loadRemoteObject($umi, $buildDepth);
      }
    }
    return $obj;
  }
  /**
   * @see PersistenceFacade::create()
   */
  function &create($type, $buildDepth, $buildAttribs=null)
  {
    $obj = &parent::create($type, $buildDepth, $buildAttribs);
    return $obj;
  }
  /**
   * @see PersistenceFacade::save()
   */
  function save(&$object)
  {
    if (strlen(PersistenceFacade::getOIDParameter($object->getOID(), 'prefix')) > 0) {
      WCMFException::throwEx("The remote object '".$object->getOID()."' is immutable.", __FILE__, __LINE__);
      return false;
    }
    $result = parent::save($object);
    return $result;
  }
  /**
   * @see PersistenceFacade::delete()
   */
  function delete($oid, $recursive=true)
  {
    if (strlen(PersistenceFacade::getOIDParameter($oid, 'prefix')) > 0) {
      WCMFException::throwEx("The remote object '".$oid."' is immutable.", __FILE__, __LINE__);
      return false;
    }
    $result = parent::delete($oid, $recursive);
    return $result;
  }
  /**
   * @see PersistenceFacade::getOIDs()
   */
  function getOIDs($type, $criteria=null, $orderby=null, &$pagingInfo)
  {
    $result = parent::getOIDs($type, $criteria, $orderby, $pagingInfo);
    return $result;
  }
  /**
   * @see PersistenceFacade::loadObjects()
   */
  function loadObjects($type, $buildDepth, $criteria=null, $orderby=null, &$pagingInfo, $buildAttribs=null, $buildTypes=null)
  {
    $tmpResult = parent::loadObjects($type, $buildDepth, $criteria, $orderby, $pagingInfo, $buildAttribs, $buildTypes);
    $result = array();
    foreach($tmpResult as $obj)
    {
      if ($obj && $this->isResolvingProxies() && strlen($umi = $obj->getValue('umi')) > 0) {
        // store proxy for later reference
        $this->registerProxyObject($umi, $obj, $buildDepth);
        // load real subject
        $result[] = $this->loadRemoteObject($umi, $buildDepth);
      }
      else {
        $result[] = $obj;
      }
    }
    return $result;
  }

  /**
   * Get the proxy object for a remote object.
   * This method makes sure that a proxy for the given remote object exists. 
   * If it does not exist, it will be created.
   * @param umi The universal model id (oid with server prefix)
   * @return The proxy object.
   */
  function getProxyObject($umi, $buildDepth)
  {
    Log::debug("Get proxy object for: ".$umi, __CLASS__);
    
    // analyze umi
    $umiParts = PersistenceFacade::decomposeOID($umi);
    $umiPrefix = $umiParts['prefix'];
    
    // local objects don't have a proxy
    if (strlen($umiPrefix) == 0) {
      return null;
    }
    
    // check if the proxy object was loaded already
    $proxy = $this->getRegisteredProxyObject($umi, $buildDepth);
    
    // search the proxy object if requested for the first time
    if (!$proxy)
    {
      $persistenceFacade = PersistenceFacade::getInstance();
      if ($persistenceFacade instanceof RemoteCapablePersistenceFacadeImpl) {
        $oldState = $persistenceFacade->isResolvingProxies();
        $persistenceFacade->setResolveProxies(false);
      }
      $proxy = $persistenceFacade->loadFirstObject($umiParts['type'], $buildDepth, array($umiParts['type'].'.umi' => $umi));
      if ($persistenceFacade instanceof RemoteCapablePersistenceFacadeImpl) {
        $persistenceFacade->setResolveProxies($oldState);
      }
      if (!$proxy) {
        // the proxy has to be created
        Log::debug("Creating...", __CLASS__);
        $proxy = $persistenceFacade->create($umiParts['type'], BUILDDEPTH_SINGLE);
        $proxy->setValue('umi', $umi, DATATYPE_ATTRIBUTE);
        $proxy->save();
      }
      $this->registerProxyObject($umi, $proxy, $buildDepth);
    }
    Log::debug("Proxy oid: ".$proxy->getOID(), __CLASS__);
    return $proxy;
  }
  
  /**
   * Load the real subject of a proxy from the remote instance.
   * @param umi The universal model id (oid with server prefix)
   * @param buildDepth buildDepth One of the BUILDDEPTH constants or a number describing the number of generations to build (except BUILDDEPTH_REQUIRED) 
   */
  function loadRemoteObject($umi, $buildDepth)
  {
    Log::debug("Resolve proxy object for: ".$umi, __CLASS__);

    // analyze umi
    $umiParts = PersistenceFacade::decomposeOID($umi);
    $umiPrefix = $umiParts['prefix'];
    
    // check if the remote object was loaded already
    $obj = $this->getRegisteredRemoteObject($umi, $buildDepth);
    
    // resolve the object if requested for the first time
    if (!$obj)
    {
      Log::debug("Retrieving...", __CLASS__);
      
      // determine remote oid
      $oid = PersistenceFacade::composeOID(
        array('type' => $umiParts['type'], 'id' => $umiParts['id'])
      );
      $serverKey = array_pop(split(':', $umiPrefix));
    
      // create the request
      $request = new Request(
        '', 
        '', 
        'display', 
        array(
          'oid' => $oid,
          'depth' => "".$buildDepth,
          'omitMetaData' => true,
          'translateValues' => $this->_isTranslatingValues
        )
      );
      Log::debug("Request:\n".$request->toString(), __CLASS__);
      
      // do the remote call
      $facade = RemotingFacade::getInstance();
      $response = $facade->doCall($serverKey, $request);
      $obj = $response->getValue('node');
      if ($obj)
      {
        // set umis instead of oids
        $iter = new NodeIterator($obj);
        while (!$iter->isEnd())
        {
          $curNode = &$iter->getCurrentObject();
          $oids = $this->makeUmis(array($curNode->getOID()), $umiPrefix);
          $curNode->setOID($oids[0]);
          $parentOIDs = $this->makeUmis($curNode->getProperty('parentoids'), $umiPrefix);
          $curNode->setProperty('parentoids', $parentOIDs);
          $childOIDs = $this->makeUmis($curNode->getProperty('childoids'), $umiPrefix);
          $curNode->setProperty('childoids', $childOIDs);
          $iter->proceed();
        }        
        // set the proxy oid as attribute
        $proxy = $this->getProxyObject($umi, $buildDepth);
        if ($proxy) {
                    if (strlen(PersistenceFacade::getOIDParameter($proxy->getOID(), 'prefix')) > 0) {
                                Log::debug("NOT A PROXY: ".WCMFException::getStackTrace(), __CLASS__);
                        }
                $obj->setValue('_proxyOid', $proxy->getOID(), DATATYPE_IGNORE);
      
          // add proxy relations to the remote object
          $children = $proxy->getChildren();
          for($i=0, $count=sizeof($children); $i<$count; $i++) {
                $obj->addChild($children[$i]);
          }
          $parents = $proxy->getParents();
          for($i=0, $count=sizeof($parents); $i<$count; $i++) {
                $obj->addParent($parents[$i]);
          }
        }
        $this->registerRemoteObject($umi, $obj, $buildDepth);
      }      
    }
    
    if (Log::isDebugEnabled(__CLASS__)) {
      if ($obj) {
        Log::debug("Resolved to: ".$obj->toString(), __CLASS__);
      }
      else {
        Log::debug("Could not resolve: ".$umi, __CLASS__);
      }
    }
    return $obj;
  }

  /**
   * Save a proxy object in the session.
   * @param umi The universal model id (oid with server prefix)
   * @param obj The proxy object.
   * @param buildDepth The depth the object was loaded.
   */
  function registerProxyObject($umi, &$obj, $buildDepth)
  {
    if (strlen(PersistenceFacade::getOIDParameter($obj->getOID(), 'prefix')) > 0) {
      Log::debug("NOT A PROXY: ".WCMFException::getStackTrace(), __CLASS__);
      return;
    }
    $this->registerObject($umi, $obj, $buildDepth, self::PROXY_OBJECTS_SESSION_VARNAME);
  }
  
  /**
   * Save a remote object in the session.
   * @param umi The universal model id (oid with server prefix)
   * @param obj The remote object.
   * @param buildDepth The depth the object was loaded.
   */
  function registerRemoteObject($umi, &$obj, $buildDepth)
  {
    // TODO: fix caching remote objects (invalidate cache entry, if an association to the object changes)
    return;

    $this->registerObject($umi, $obj, $buildDepth, self::REMOTE_OBJECTS_SESSION_VARNAME);
  }
  
  /**
   * Save a object in the given session variable.
   * @param umi The universal model id (oid with server prefix)
   * @param obj The object to register.
   * @param buildDepth The depth the object was loaded [default: BUILDDEPTH_SINGLE].
   * @param varName The session variable name.
   */
  function registerObject($umi, &$obj, $buildDepth=BUILDDEPTH_SINGLE, $varName)
  {
    if ($buildDepth == 0) {
      $buildDepth=BUILDDEPTH_SINGLE;
    }
    // save the object in the session
    $session = &SessionData::getInstance();
    $objects = &$session->get($varName);
    if (!isset($objects[$umi])) {
      $objects[$umi] = array();
    }
    $objects[$umi][$buildDepth] = &$obj;
    $session->set($varName, $objects);
    
    // register class definitions in session
    $objectFactory = &ObjectFactory::getInstance();
    $classFile = BASE.$objectFactory->getClassfileFromConfig(get_class($obj));
    $mapperClassFile = BASE.$objectFactory->getClassfileFromConfig(get_class($obj->getMapper()));
    $session->addClassDefinitions(array($classFile, $mapperClassFile));
  }

  /**
   * Get a proxy object from the session.
   * @param umi The universal model id (oid with server prefix)
   * @param buildDepth The requested build depth.
   * @return The proxy object or null if not found.
   */
  function getRegisteredProxyObject($umi, $buildDepth)
  {
    $proxy = $this->getRegisteredObject($umi, $buildDepth, self::PROXY_OBJECTS_SESSION_VARNAME);
    return $proxy;
  }
  
  /**
   * Get a remote object from the session.
   * @param umi The universal model id (oid with server prefix)
   * @param buildDepth The requested build depth.
   * @return The remote object or null if not found.
   */
  function getRegisteredRemoteObject($umi, $buildDepth)
  {
        $object = $this->getRegisteredObject($umi, $buildDepth, self::REMOTE_OBJECTS_SESSION_VARNAME);;
    return $object;
  }
  
  /**
   * Get a object from the given session variable.
   * @param umi The universal model id (oid with server prefix)
   * @param buildDepth The requested build depth [default: BUILDDEPTH_SINGLE].
   * @return The object or null if not found.
   */
  function getRegisteredObject($umi, $buildDepth=BUILDDEPTH_SINGLE, $varName)
  {
    if ($buildDepth == 0) {
      $buildDepth=BUILDDEPTH_SINGLE;
    }
    $session = &SessionData::getInstance();
    $objects = &$session->get($varName);
    if (isset($objects[$umi]) && isset($objects[$umi][$buildDepth])) {
      return $objects[$umi][$buildDepth];
    }
    // check if an object with larger build depth was stored already
    if ($buildDepth == BUILDDEPTH_SINGLE) {
      $existingDepths = array_keys($objects[$umi]);
      foreach($existingDepths as $depth) {
        if ($depth > 0 || $depth == BUILDDEPTH_INFINITE) {
          return $objects[$umi][$depth];
        }
      }
    }
    return null;
  }
  /**
   * Replace all object ids in an array with the umis according to 
   * the given umiPrefix.
   * @param oids The array of oids
   * @param umiPrefix The umi prefix
   * @return The array of umis
   */
  function makeUmis($oids, $umiPrefix)
  {
        $result = array();
        foreach ($oids as $oid)
        {
      $oidParts = PersistenceFacade::decomposeOID($oid);
      if (strlen($oidParts['prefix']) == 0)
      {
        $umi = PersistenceFacade::composeOID(
          array('prefix' => $umiPrefix, 'type' => $oidParts['type'], 'id' => $oidParts['id'])
        );
        $result[] = $umi;
      }
    }
    return $result;
  }
}
?>