vendor/jackalope/jackalope/src/Jackalope/Session.php line 271

  1. <?php
  3. namespace Jackalope;
  5. use PHPCR\Util\PathHelper;
  6. use Exception;
  7. use PHPCR\RepositoryInterface;
  8. use PHPCR\SessionInterface;
  9. use PHPCR\SimpleCredentials;
  10. use PHPCR\CredentialsInterface;
  11. use PHPCR\PathNotFoundException;
  12. use PHPCR\ItemNotFoundException;
  13. use PHPCR\ItemExistsException;
  14. use PHPCR\RepositoryException;
  15. use PHPCR\UnsupportedRepositoryOperationException;
  16. use InvalidArgumentException;
  17. use PHPCR\Security\AccessControlException;
  18. use Jackalope\ImportExport\ImportExport;
  19. use Jackalope\Transport\TransportInterface;
  20. use Jackalope\Transport\TransactionInterface;
  21. use Traversable;
  23. /**
  24.  * {@inheritDoc}
  25.  *
  26.  * Jackalope adds the SessionOption concept to handle session specific tweaking
  27.  * and optimization. We distinguish between options that are purely
  28.  * optimization but do not affect the behaviour and those that are change the
  29.  * behaviour.
  30.  *
  31.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  32.  * @license http://opensource.org/licenses/MIT MIT License
  33.  *
  34.  * @api
  35.  */
  36. class Session implements SessionInterface
  37. {
  38.     /**
  39.      * Constant for setSessionOption to manage the fetch depth.
  40.      *
  41.      * This option is used to set the depth with which nodes should be fetched from the backend to optimize
  42.      * performance when you know you will need the child nodes.
  43.      */
  44.     const OPTION_FETCH_DEPTH = 'jackalope.fetch_depth';
  46.     /**
  47.      * Constant for setSessionOption to manage whether nodes having mix:lastModified should automatically be updated.
  48.      *
  49.      * Disable if you want to manually control this information, e.g. in a PHPCR-ODM listener.
  50.      */
  51.     const OPTION_AUTO_LASTMODIFIED = 'jackalope.auto_lastmodified';
  53.     /**
  54.      * A registry for all created sessions to be able to reference them by id in
  55.      * the stream wrapper for lazy loading binary properties.
  56.      *
  57.      * Keys are spl_object_hash'es for the sessions which are the values
  58.      *
  59.      * @var array
  60.      */
  61.     protected static $sessionRegistry = [];
  63.     /**
  64.      * The factory to instantiate objects
  65.      *
  66.      * @var FactoryInterface
  67.      */
  68.     protected $factory;
  70.     /**
  71.      * @var Repository
  72.      */
  73.     protected $repository;
  75.     /**
  76.      * @var Workspace
  77.      */
  78.     protected $workspace;
  80.     /**
  81.      * @var ObjectManager
  82.      */
  83.     protected $objectManager;
  85.     /**
  86.      * @var SimpleCredentials
  87.      */
  88.     protected $credentials;
  90.     /**
  91.      * Whether this session is in logged out state and can not be used anymore
  92.      *
  93.      * @var bool
  94.      */
  95.     protected $logout = false;
  97.     /**
  98.      * The namespace registry.
  99.      *
  100.      * It is only used to check prefixes and at setup. Session namespace remapping must be handled locally.
  101.      *
  102.      * @var NamespaceRegistry
  103.      */
  104.     protected $namespaceRegistry;
  106.     /**
  107.      * List of local namespaces
  108.      *
  109.      * TODO: implement local namespace rewriting
  110.      * see jackrabbit-spi-commons/src/main/java/org/apache/jackrabbit/spi/commons/conversion/PathParser.java and friends
  111.      * for how this is done in jackrabbit
  112.      */
  113.     //protected $localNamespaces;
  115.     /** Creates a session
  116.      *
  117.      * Builds the corresponding workspace instance
  118.      *
  119.      * @param FactoryInterface  $factory       the object factory
  120.      * @param Repository        $repository
  121.      * @param string            $workspaceName the workspace name that is used
  122.      * @param SimpleCredentials $credentials   the credentials that where
  123.      *      used to log in, in order to implement Session::getUserID()
  124.      *      if they are null, getUserID returns null
  125.      * @param TransportInterface $transport the transport implementation
  126.      */
  127.     public function __construct(FactoryInterface $factory, Repository $repository, $workspaceName, SimpleCredentials $credentials = null, TransportInterface $transport)
  128.     {
  129.         $this->factory = $factory;
  130.         $this->repository = $repository;
  131.         $this->objectManager = $this->factory->get(ObjectManager::class, [$transport, $this]);
  132.         $this->workspace = $this->factory->get(Workspace::class, [$this, $this->objectManager, $workspaceName]);
  133.         $this->credentials = $credentials;
  134.         $this->namespaceRegistry = $this->workspace->getNamespaceRegistry();
  136.         self::registerSession($this);
  138.         $transport->setNodeTypeManager($this->workspace->getNodeTypeManager());
  139.     }
  141.     /**
  142.      * {@inheritDoc}
  143.      *
  144.      * @api
  145.      */
  146.     public function getRepository()
  147.     {
  148.         return $this->repository;
  149.     }
  151.     /**
  152.      * {@inheritDoc}
  153.      *
  154.      * @api
  155.      */
  156.     public function getUserID()
  157.     {
  158.         if (null === $this->credentials) {
  159.             return null;
  160.         }
  162.         return $this->credentials->getUserID(); //TODO: what if its not simple credentials? what about anonymous login?
  163.     }
  165.     /**
  166.      * {@inheritDoc}
  167.      *
  168.      * @api
  169.      */
  170.     public function getAttributeNames()
  171.     {
  172.         if (null === $this->credentials) {
  173.             return [];
  174.         }
  176.         return $this->credentials->getAttributeNames();
  177.     }
  179.     /**
  180.      * {@inheritDoc}
  181.      *
  182.      * @api
  183.      */
  184.     public function getAttribute($name)
  185.     {
  186.         if (null === $this->credentials) {
  187.             return null;
  188.         }
  190.         return $this->credentials->getAttribute($name);
  191.     }
  193.     /**
  194.      * {@inheritDoc}
  195.      *
  196.      * @api
  197.      */
  198.     public function getWorkspace()
  199.     {
  200.         return $this->workspace;
  201.     }
  203.     /**
  204.      * {@inheritDoc}
  205.      *
  206.      * @api
  207.      */
  208.     public function getRootNode()
  209.     {
  210.         return $this->getNode('/');
  211.     }
  213.     /**
  214.      * {@inheritDoc}
  215.      *
  216.      * @api
  217.      */
  218.     public function impersonate(CredentialsInterface $credentials)
  219.     {
  220.         throw new UnsupportedRepositoryOperationException('Not supported');
  221.     }
  223.     /**
  224.      * {@inheritDoc}
  225.      *
  226.      * @api
  227.      */
  228.     public function getNodeByIdentifier($id)
  229.     {
  230.         return $this->objectManager->getNodeByIdentifier($id);
  231.     }
  233.     /**
  234.      * {@inheritDoc}
  235.      *
  236.      * @api
  237.      */
  238.     public function getNodesByIdentifier($ids)
  239.     {
  240.         if (! is_array($ids) && ! $ids instanceof Traversable) {
  241.             $hint = is_object($ids) ? get_class($ids) : gettype($ids);
  242.             throw new InvalidArgumentException("Not a valid array or Traversable: $hint");
  243.         }
  245.         return $this->objectManager->getNodesByIdentifier($ids);
  246.     }
  248.     /**
  249.      * {@inheritDoc}
  250.      *
  251.      * @api
  252.      */
  253.     public function getItem($absPath)
  254.     {
  255.         if (! is_string($absPath) || strlen($absPath) === 0 || '/' !== $absPath[0]) {
  256.             throw new PathNotFoundException('It is forbidden to call getItem on session with a relative path');
  257.         }
  259.         if ($this->nodeExists($absPath)) {
  260.             return $this->getNode($absPath);
  261.         }
  263.         return $this->getProperty($absPath);
  264.     }
  266.     /**
  267.      * {@inheritDoc}
  268.      *
  269.      * @api
  270.      */
  271.     public function getNode($absPath, $depthHint = -1)
  272.     {
  273.         if (-1 !== $depthHint) {
  274.             $depth = $this->getSessionOption(self::OPTION_FETCH_DEPTH);
  275.             $this->setSessionOption(self::OPTION_FETCH_DEPTH, $depthHint);
  276.         }
  278.         try {
  279.             $node = $this->objectManager->getNodeByPath($absPath);
  280.             if (isset($depth)) {
  281.                 $this->setSessionOption(self::OPTION_FETCH_DEPTH, $depth);
  282.             }
  284.             return $node;
  285.         } catch (ItemNotFoundException $e) {
  286.             if (isset($depth)) {
  287.                 $this->setSessionOption(self::OPTION_FETCH_DEPTH, $depth);
  288.             }
  289.             throw new PathNotFoundException($e->getMessage(), $e->getCode(), $e);
  290.         }
  291.     }
  293.     /**
  294.      * {@inheritDoc}
  295.      *
  296.      * @api
  297.      */
  298.     public function getNodes($absPaths)
  299.     {
  300.         if (! is_array($absPaths) && ! $absPaths instanceof Traversable) {
  301.             $hint = is_object($absPaths) ? get_class($absPaths) : gettype($absPaths);
  302.             throw new InvalidArgumentException("Not a valid array or Traversable: $hint");
  303.         }
  305.         return $this->objectManager->getNodesByPath($absPaths);
  306.     }
  308.     /**
  309.      * {@inheritDoc}
  310.      *
  311.      * @api
  312.      */
  313.     public function getProperty($absPath)
  314.     {
  315.         try {
  316.             return $this->objectManager->getPropertyByPath($absPath);
  317.         } catch (ItemNotFoundException $e) {
  318.             throw new PathNotFoundException($e->getMessage(), $e->getCode(), $e);
  319.         }
  320.     }
  322.     public function getProperties($absPaths)
  323.     {
  324.         if (! is_array($absPaths) && ! $absPaths instanceof Traversable) {
  325.             $hint = is_object($absPaths) ? get_class($absPaths) : gettype($absPaths);
  326.             throw new InvalidArgumentException("Not a valid array or Traversable: $hint");
  327.         }
  329.         return $this->objectManager->getPropertiesByPath($absPaths);
  330.     }
  332.     /**
  333.      * {@inheritDoc}
  334.      *
  335.      * @api
  336.      */
  337.     public function itemExists($absPath)
  338.     {
  339.         if ($absPath === '/') {
  340.             return true;
  341.         }
  343.         return $this->nodeExists($absPath) || $this->propertyExists($absPath);
  344.     }
  346.     /**
  347.      * {@inheritDoc}
  348.      *
  349.      * @api
  350.      */
  351.     public function nodeExists($absPath)
  352.     {
  353.         if ($absPath === '/') {
  354.             return true;
  355.         }
  357.         try {
  358.             //OPTIMIZE: avoid throwing and catching errors would improve performance if many node exists calls are made
  359.             //would need to communicate to the lower layer that we do not want exceptions
  360.             $this->objectManager->getNodeByPath($absPath);
  361.         } catch (ItemNotFoundException $e) {
  362.             return false;
  363.         }
  365.         return true;
  366.     }
  368.     /**
  369.      * {@inheritDoc}
  370.      *
  371.      * @api
  372.      */
  373.     public function propertyExists($absPath)
  374.     {
  375.         try {
  376.             //OPTIMIZE: avoid throwing and catching errors would improve performance if many node exists calls are made
  377.             //would need to communicate to the lower layer that we do not want exceptions
  378.             $this->getProperty($absPath);
  379.         } catch (PathNotFoundException $e) {
  380.             return false;
  381.         }
  383.         return true;
  384.     }
  386.     /**
  387.      * {@inheritDoc}
  388.      *
  389.      * @api
  390.      */
  391.     public function move($srcAbsPath, $destAbsPath)
  392.     {
  393.         try {
  394.             $parent = $this->objectManager->getNodeByPath(PathHelper::getParentPath($destAbsPath));
  395.         } catch (ItemNotFoundException $e) {
  396.             throw new PathNotFoundException("Target path can not be found: $destAbsPath", $e->getCode(), $e);
  397.         }
  399.         if ($parent->hasNode(PathHelper::getNodeName($destAbsPath))) {
  400.             // TODO same-name siblings
  401.             throw new ItemExistsException('Target node already exists at '.$destAbsPath);
  402.         }
  404.         if ($parent->hasProperty(PathHelper::getNodeName($destAbsPath))) {
  405.             throw new ItemExistsException('Target property already exists at '.$destAbsPath);
  406.         }
  408.         $this->objectManager->moveNode($srcAbsPath, $destAbsPath);
  409.     }
  411.     /**
  412.      * {@inheritDoc}
  413.      *
  414.      * @api
  415.      */
  416.     public function removeItem($absPath)
  417.     {
  418.         $item = $this->getItem($absPath);
  419.         $item->remove();
  420.     }
  422.     /**
  423.      * {@inheritDoc}
  424.      *
  425.      * Wraps the save operation into a transaction if transactions are enabled
  426.      * but we are not currently inside a transaction and rolls back on error.
  427.      *
  428.      * If transactions are disabled, errors on save can lead to partial saves
  429.      * and inconsistent data.
  430.      *
  431.      * @api
  432.      */
  433.     public function save()
  434.     {
  435.         if ($this->getTransport() instanceof TransactionInterface) {
  436.             try {
  437.                 $utx = $this->workspace->getTransactionManager();
  438.             } catch (UnsupportedRepositoryOperationException $e) {
  439.                 // user transactions where disabled for this session, do no automatic transaction.
  440.             }
  441.         }
  443.         if (isset($utx) && !$utx->inTransaction()) {
  444.             // do the operation in a short transaction
  445.             $utx->begin();
  446.             try {
  447.                 $this->objectManager->save();
  448.                 $utx->commit();
  449.             } catch (Exception $e) {
  450.                 // if anything goes wrong, rollback this mess
  451.                 try {
  452.                     $utx->rollback();
  453.                 } catch (Exception $rollbackException) {
  454.                     // ignore this exception
  455.                 }
  456.                 // but do not eat this exception
  457.                 throw $e;
  458.             }
  459.         } else {
  460.             $this->objectManager->save();
  461.         }
  462.     }
  464.     /**
  465.      * {@inheritDoc}
  466.      *
  467.      * @api
  468.      */
  469.     public function refresh($keepChanges)
  470.     {
  471.         $this->objectManager->refresh($keepChanges);
  472.     }
  474.     /**
  475.      * Jackalope specific hack to drop the state of the current session
  476.      *
  477.      * Removes all cached objects, planned changes etc without making the
  478.      * objects aware of it. Was done as a cheap replacement for refresh
  479.      * in testing.
  480.      *
  481.      * @deprecated: this will screw up major, as the user of the api can still have references to nodes. USE refresh instead!
  482.      */
  483.     public function clear()
  484.     {
  485.         trigger_error('Use Session::refresh instead, this method is extremely unsafe', E_USER_DEPRECATED);
  486.         $this->objectManager->clear();
  487.     }
  489.     /**
  490.      * {@inheritDoc}
  491.      *
  492.      * @api
  493.      */
  494.     public function hasPendingChanges()
  495.     {
  496.         return $this->objectManager->hasPendingChanges();
  497.     }
  499.     /**
  500.      * {@inheritDoc}
  501.      *
  502.      * @api
  503.      */
  504.     public function hasPermission($absPath, $actions)
  505.     {
  506.         $actualPermissions = $this->objectManager->getPermissions($absPath);
  507.         $requestedPermissions = explode(',', $actions);
  509.         foreach ($requestedPermissions as $perm) {
  510.             if (! in_array(strtolower(trim($perm)), $actualPermissions)) {
  511.                 return false;
  512.             }
  513.         }
  515.         return true;
  516.     }
  518.     /**
  519.      * {@inheritDoc}
  520.      *
  521.      * @api
  522.      */
  523.     public function checkPermission($absPath, $actions)
  524.     {
  525.         if (! $this->hasPermission($absPath, $actions)) {
  526.             throw new AccessControlException($absPath);
  527.         }
  528.     }
  530.     /**
  531.      * {@inheritDoc}
  532.      *
  533.      * Jackalope does currently not check anything and always return true.
  534.      *
  535.      * @api
  536.      */
  537.     public function hasCapability($methodName, $target, array $arguments)
  538.     {
  539.         //we never determine whether operation can be performed as it is optional ;-)
  540.         //TODO: could implement some
  541.         return true;
  542.     }
  544.     /**
  545.      * {@inheritDoc}
  546.      *
  547.      * @api
  548.      */
  549.     public function importXML($parentAbsPath, $uri, $uuidBehavior)
  550.     {
  551.         ImportExport::importXML(
  552.             $this->getNode($parentAbsPath),
  553.             $this->workspace->getNamespaceRegistry(),
  554.             $uri,
  555.             $uuidBehavior
  556.         );
  557.     }
  559.     /**
  560.      * {@inheritDoc}
  561.      *
  562.      * @api
  563.      */
  564.     public function exportSystemView($absPath, $stream, $skipBinary, $noRecurse)
  565.     {
  566.         ImportExport::exportSystemView(
  567.             $this->getNode($absPath),
  568.             $this->workspace->getNamespaceRegistry(),
  569.             $stream,
  570.             $skipBinary,
  571.             $noRecurse
  572.         );
  573.     }
  576.     /**
  577.      * {@inheritDoc}
  578.      *
  579.      * @api
  580.      */
  581.     public function exportDocumentView($absPath, $stream, $skipBinary, $noRecurse)
  582.     {
  583.         ImportExport::exportDocumentView(
  584.             $this->getNode($absPath),
  585.             $this->workspace->getNamespaceRegistry(),
  586.             $stream,
  587.             $skipBinary,
  588.             $noRecurse
  589.         );
  590.     }
  594.     /**
  595.      * {@inheritDoc}
  596.      *
  597.      * @api
  598.      */
  599.     public function setNamespacePrefix($prefix, $uri)
  600.     {
  601.         $this->namespaceRegistry->checkPrefix($prefix);
  602.         throw new NotImplementedException('TODO: implement session scope remapping of namespaces');
  603.         //this will lead to rewrite all names and paths in requests and replies. part of this can be done in ObjectManager::normalizePath
  604.     }
  606.     /**
  607.      * {@inheritDoc}
  608.      *
  609.      * @api
  610.      */
  611.     public function getNamespacePrefixes()
  612.     {
  613.         //TODO: once setNamespacePrefix is implemented, must take session remaps into account
  614.         return $this->namespaceRegistry->getPrefixes();
  615.     }
  617.     /**
  618.      * {@inheritDoc}
  619.      *
  620.      * @api
  621.      */
  622.     public function getNamespaceURI($prefix)
  623.     {
  624.         //TODO: once setNamespacePrefix is implemented, must take session remaps into account
  625.         return $this->namespaceRegistry->getURI($prefix);
  626.     }
  628.     /**
  629.      * {@inheritDoc}
  630.      *
  631.      * @api
  632.      */
  633.     public function getNamespacePrefix($uri)
  634.     {
  635.         //TODO: once setNamespacePrefix is implemented, must take session remaps into account
  636.         return $this->namespaceRegistry->getPrefix($uri);
  637.     }
  639.     /**
  640.      * {@inheritDoc}
  641.      *
  642.      * @api
  643.      */
  644.     public function logout()
  645.     {
  646.         //OPTIMIZATION: flush object manager to help garbage collector
  647.         $this->logout = true;
  649.         if ($this->getRepository()->getDescriptor(RepositoryInterface::OPTION_LOCKING_SUPPORTED)) {
  650.             $this->getWorkspace()->getLockManager()->logout();
  651.         }
  653.         self::unregisterSession($this);
  654.         $this->getTransport()->logout();
  655.     }
  657.     /**
  658.      * {@inheritDoc}
  659.      *
  660.      * @api
  661.      */
  662.     public function isLive()
  663.     {
  664.         return ! $this->logout;
  665.     }
  667.     /**
  668.      * {@inheritDoc}
  669.      *
  670.      * @api
  671.      */
  672.     public function getAccessControlManager()
  673.     {
  674.         throw new UnsupportedRepositoryOperationException();
  675.     }
  677.     /**
  678.      * {@inheritDoc}
  679.      *
  680.      * @api
  681.      */
  682.     public function getRetentionManager()
  683.     {
  684.         throw new UnsupportedRepositoryOperationException();
  685.     }
  687.     /**
  688.      * Implementation specific: The object manager is also used by other components, i.e. the QueryManager.
  689.      *
  690.      * @return ObjectManager the object manager associated with this session
  691.      *
  692.      * @private
  693.      */
  694.     public function getObjectManager()
  695.     {
  696.         return $this->objectManager;
  697.     }
  699.     /**
  700.      * Implementation specific: The transport implementation is also used by other components,
  701.      * i.e. the NamespaceRegistry
  702.      *
  703.      * @return TransportInterface the transport implementation associated with
  704.      *      this session.
  705.      *
  706.      * @private
  707.      */
  708.     public function getTransport()
  709.     {
  710.         return $this->objectManager->getTransport();
  711.     }
  713.     /**
  714.      * Implementation specific: register session in session registry for the stream wrapper.
  715.      *
  716.      * @param Session $session the session to register
  717.      *
  718.      * @private
  719.      */
  720.     protected static function registerSession(Session $session)
  721.     {
  722.         $key = $session->getRegistryKey();
  723.         self::$sessionRegistry[$key] = $session;
  724.     }
  726.     /**
  727.      * Implementation specific: unregister session in session registry on logout.
  728.      *
  729.      * @param Session $session the session to unregister
  730.      *
  731.      * @private
  732.      */
  733.     protected static function unregisterSession(Session $session)
  734.     {
  735.         $key = $session->getRegistryKey();
  736.         unset(self::$sessionRegistry[$key]);
  737.     }
  739.     /**
  740.      * Implementation specific: create an id for the session registry so that the stream wrapper can identify it.
  741.      *
  742.      * @private
  743.      *
  744.      * @return string an id for this session
  745.      */
  746.     public function getRegistryKey()
  747.     {
  748.         return spl_object_hash($this);
  749.     }
  751.     /**
  752.      * Implementation specific: get a session from the session registry for the stream wrapper.
  753.      *
  754.      * @param string $key key for the session
  755.      *
  756.      * @return Session|null the session or null if none is registered with the given key
  757.      *
  758.      * @private
  759.      */
  760.     public static function getSessionFromRegistry($key)
  761.     {
  762.         if (isset(self::$sessionRegistry[$key])) {
  763.             return self::$sessionRegistry[$key];
  764.         }
  766.         return null;
  767.     }
  769.     /**
  770.      * Sets a session specific option.
  771.      *
  772.      * @param string $key   the key to be set
  773.      * @param mixed  $value the value to be set
  774.      *
  775.      * @throws InvalidArgumentException if the option is unknown
  776.      * @throws RepositoryException      if this option is not supported and is
  777.      *      a behaviour relevant option
  778.      *
  779.      * @see BaseTransport::setFetchDepth($value);
  780.      */
  782.     public function setSessionOption($key, $value)
  783.     {
  784.         switch ($key) {
  785.             case self::OPTION_FETCH_DEPTH:
  786.                 $this->getTransport()->setFetchDepth($value);
  787.                 break;
  788.             case self::OPTION_AUTO_LASTMODIFIED:
  789.                 $this->getTransport()->setAutoLastModified($value);
  790.                 break;
  791.             default:
  792.                 throw new InvalidArgumentException("Unknown option: $key");
  793.         }
  794.     }
  796.     /**
  797.      * Gets a session specific option.
  798.      *
  799.      * @param string $key the key to be gotten
  800.      *
  801.      * @return bool
  802.      *
  803.      * @throws InvalidArgumentException if the option is unknown
  804.      *
  805.      * @see setSessionOption($key, $value);
  806.      */
  807.     public function getSessionOption($key)
  808.     {
  809.         switch ($key) {
  810.             case self::OPTION_FETCH_DEPTH:
  811.                 return $this->getTransport()->getFetchDepth();
  812.             case self::OPTION_AUTO_LASTMODIFIED:
  813.                 return $this->getTransport()->getAutoLastModified();
  814.         }
  816.         throw new InvalidArgumentException("Unknown option: $key");
  817.     }
  818. }