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

Open in your IDE?
  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. }