import java.io.InputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
+import java.time.Instant;
import java.util.ArrayList;
import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
+import java.util.UUID;
import java.util.concurrent.ForkJoinPool;
import javax.jcr.Node;
import javax.jcr.PropertyIterator;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
+import javax.jcr.Session;
import javax.jcr.Value;
+import javax.jcr.ValueFactory;
import javax.jcr.nodetype.NodeType;
+import javax.jcr.nodetype.NodeTypeManager;
import javax.xml.namespace.QName;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import org.argeo.api.acr.Content;
+import org.argeo.api.acr.CrAttributeType;
import org.argeo.api.acr.NamespaceUtils;
-import org.argeo.api.acr.spi.ContentProvider;
import org.argeo.api.acr.spi.ProvidedSession;
import org.argeo.api.cms.CmsConstants;
import org.argeo.cms.acr.AbstractContent;
/** A JCR {@link Node} accessed as {@link Content}. */
public class JcrContent extends AbstractContent {
-// private Node jcrNode;
-
private JcrContentProvider provider;
private String jcrWorkspace;
private String jcrPath;
+ private final boolean isMountBase;
+
+ /* OPTIMISATIONS */
+ /**
+ * While we want to support thread-safe access, it is very likely that only
+ * thread and only one sesssion will be used (typically from a single-threaded
+ * UI). We therefore cache was long as the same thread is calling.
+ */
+ private Thread lastRetrievingThread = null;
+ private Node cachedNode = null;
+ private boolean caching = true;
+
protected JcrContent(ProvidedSession session, JcrContentProvider provider, String jcrWorkspace, String jcrPath) {
super(session);
this.provider = provider;
this.jcrWorkspace = jcrWorkspace;
this.jcrPath = jcrPath;
+
+ this.isMountBase = ContentUtils.SLASH_STRING.equals(jcrPath);
}
+ /*
+ * READ
+ */
+
@Override
public QName getName() {
String name = Jcr.getName(getJcrNode());
@SuppressWarnings("unchecked")
@Override
public <A> Optional<A> get(QName key, Class<A> clss) {
- if (isDefaultAttrTypeRequested(clss)) {
- return Optional.of((A) get(getJcrNode(), key.toString()));
- }
- return Optional.of((A) Jcr.get(getJcrNode(), key.toString()));
+ Object value = get(getJcrNode(), key.toString());
+ if (value instanceof List<?> lst)
+ return Optional.of((A) lst);
+ // TODO check other collections?
+ return CrAttributeType.cast(clss, value);
}
@Override
}
}
- public Node getJcrNode() {
- try {
- // TODO caching?
- return provider.getJcrSession(getSession(), jcrWorkspace).getNode(jcrPath);
- } catch (RepositoryException e) {
- throw new JcrException("Cannot retrieve " + jcrPath + " from workspace " + jcrWorkspace, e);
- }
- }
-
/** Cast to a standard Java object. */
static Object get(Node node, String property) {
try {
+ if (!node.hasProperty(property))
+ return null;
Property p = node.getProperty(property);
if (p.isMultiple()) {
Value[] values = p.getValues();
return convertSingleValue(value);
}
} catch (RepositoryException e) {
- throw new JcrException("Cannot cast value from " + property + " of node " + node, e);
+ throw new JcrException("Cannot cast value from " + property + " of " + node, e);
}
}
- static Object convertSingleValue(Value value) throws RepositoryException {
- switch (value.getType()) {
- case PropertyType.STRING:
- return value.getString();
- case PropertyType.DOUBLE:
- return (Double) value.getDouble();
- case PropertyType.LONG:
- return (Long) value.getLong();
- case PropertyType.BOOLEAN:
- return (Boolean) value.getBoolean();
- case PropertyType.DATE:
- Calendar calendar = value.getDate();
- return calendar.toInstant();
- case PropertyType.BINARY:
- throw new IllegalArgumentException("Binary is not supported as an attribute");
- default:
- return value.getString();
- }
- }
-
- class JcrContentIterator implements Iterator<Content> {
- private final NodeIterator nodeIterator;
- // we keep track in order to be able to delete it
- private JcrContent current = null;
-
- protected JcrContentIterator(NodeIterator nodeIterator) {
- this.nodeIterator = nodeIterator;
- }
-
- @Override
- public boolean hasNext() {
- return nodeIterator.hasNext();
- }
-
- @Override
- public Content next() {
- current = new JcrContent(getSession(), provider, jcrWorkspace, Jcr.getPath(nodeIterator.nextNode()));
- return current;
- }
-
- @Override
- public void remove() {
- if (current != null) {
- Jcr.remove(current.getJcrNode());
+ @Override
+ public boolean isMultiple(QName key) {
+ Node node = getJcrNode();
+ String p = NamespaceUtils.toFullyQualified(key);
+ try {
+ if (node.hasProperty(p)) {
+ Property property = node.getProperty(p);
+ return property.isMultiple();
+ } else {
+ return false;
}
+ } catch (RepositoryException e) {
+ throw new JcrException(
+ "Cannot check multiplicityof property " + p + " of " + jcrPath + " in " + jcrWorkspace, e);
}
-
}
@Override
try {
// Note: it is important to to use the default way (recursing through parents),
// since the session may not have access to parent nodes
- return ContentUtils.ROOT_SLASH + jcrWorkspace + getJcrNode().getPath();
+ return Content.ROOT_PATH + jcrWorkspace + getJcrNode().getPath();
} catch (RepositoryException e) {
throw new JcrException("Cannot get depth of " + getJcrNode(), e);
}
@Override
public Content getParent() {
- if (Jcr.isRoot(getJcrNode())) // root
- return null;
+ if (isMountBase) {
+ String mountPath = provider.getMountPath();
+ if (mountPath == null || mountPath.equals("/"))
+ return null;
+ String[] parent = ContentUtils.getParentPath(mountPath);
+ return getSession().get(parent[0]);
+ }
+// if (Jcr.isRoot(getJcrNode())) // root
+// return null;
return new JcrContent(getSession(), provider, jcrWorkspace, Jcr.getParentPath(getJcrNode()));
}
+ @Override
+ public int getSiblingIndex() {
+ return Jcr.getIndex(getJcrNode());
+ }
+
+ /*
+ * MAP OPTIMISATIONS
+ */
+ @Override
+ public boolean containsKey(Object key) {
+ return Jcr.hasProperty(getJcrNode(), key.toString());
+ }
+
+ /*
+ * WRITE
+ */
+
+ protected Node openForEdit() {
+ Node node = getProvider().openForEdit(getSession(), jcrWorkspace, jcrPath);
+ getSession().notifyModification(this);
+ return node;
+ }
+
@Override
public Content add(QName name, QName... classes) {
if (classes.length > 0) {
QName primaryType = classes[0];
- Node child = Jcr.addNode(getJcrNode(), name.toString(), primaryType.toString());
+ Node node = openForEdit();
+ Node child = Jcr.addNode(node, name.toString(), primaryType.toString());
for (int i = 1; i < classes.length; i++) {
try {
child.addMixin(classes[i].toString());
@Override
public void remove() {
- Jcr.remove(getJcrNode());
+ Node node = openForEdit();
+ Jcr.remove(node);
}
@Override
protected void removeAttr(QName key) {
- Property property = Jcr.getProperty(getJcrNode(), key.toString());
+ Node node = openForEdit();
+ Property property = Jcr.getProperty(node, key.toString());
if (property != null) {
try {
property.remove();
}
- boolean exists() {
+ @Override
+ public Object put(QName key, Object value) {
+ try {
+ String property = NamespaceUtils.toFullyQualified(key);
+ Node node = openForEdit();
+ Object old = null;
+ if (node.hasProperty(property)) {
+ old = convertSingleValue(node.getProperty(property).getValue());
+ }
+ Value newValue = convertSingleObject(node.getSession().getValueFactory(), value);
+ node.setProperty(property, newValue);
+ // FIXME proper edition
+ node.getSession().save();
+ return old;
+ } catch (RepositoryException e) {
+ throw new JcrException("Cannot set property " + key + " on " + jcrPath + " in " + jcrWorkspace, e);
+ }
+ }
+
+ @Override
+ public void addContentClasses(QName... contentClass) throws IllegalArgumentException, JcrException {
+ try {
+ Node node = openForEdit();
+ NodeTypeManager ntm = node.getSession().getWorkspace().getNodeTypeManager();
+ List<NodeType> nodeTypes = new ArrayList<>();
+ for (QName clss : contentClass) {
+ NodeType nodeType = ntm.getNodeType(NamespaceUtils.toFullyQualified(clss));
+ if (!nodeType.isMixin())
+ throw new IllegalArgumentException(clss + " is not a mixin");
+ nodeTypes.add(nodeType);
+ }
+ for (NodeType nodeType : nodeTypes) {
+ node.addMixin(nodeType.getName());
+ }
+ // FIXME proper edition
+ node.getSession().save();
+ } catch (RepositoryException e) {
+ throw new JcrException(
+ "Cannot add content classes " + contentClass + " to " + jcrPath + " in " + jcrWorkspace, e);
+ }
+ }
+
+ /*
+ * ACCESS
+ */
+ protected boolean exists() {
try {
- return provider.getJcrSession(getSession(), jcrWorkspace).itemExists(jcrPath);
+ return getJcrSession().itemExists(jcrPath);
} catch (RepositoryException e) {
throw new JcrException("Cannot check whether " + jcrPath + " exists", e);
}
}
+ @Override
+ public boolean isParentAccessible() {
+ String jcrParentPath = ContentUtils.getParentPath(jcrPath)[0];
+ if ("".equals(jcrParentPath)) // JCR root node
+ jcrParentPath = ContentUtils.SLASH_STRING;
+ try {
+ return getJcrSession().hasPermission(jcrParentPath, Session.ACTION_READ);
+ } catch (RepositoryException e) {
+ throw new JcrException("Cannot check whether parent " + jcrParentPath + " is accessible", e);
+ }
+ }
+
/*
* ADAPTERS
*/
@SuppressWarnings("unchecked")
public <A> A adapt(Class<A> clss) {
- if (Source.class.isAssignableFrom(clss)) {
+ if (Node.class.isAssignableFrom(clss)) {
+ return (A) getJcrNode();
+ } else if (Source.class.isAssignableFrom(clss)) {
// try {
PipedOutputStream out = new PipedOutputStream();
PipedInputStream in;
ForkJoinPool.commonPool().execute(() -> {
// try (PipedOutputStream out = new PipedOutputStream(in)) {
try {
- provider.getJcrSession(getSession(), jcrWorkspace).exportDocumentView(jcrPath, out, true, false);
+ getJcrSession().exportDocumentView(jcrPath, out, true, false);
out.flush();
out.close();
} catch (IOException | RepositoryException e) {
// } catch (IOException e) {
// throw new RuntimeException("Cannot adapt " + JcrContent.this + " to " + clss, e);
// }
- } else
-
+ } else {
return super.adapt(clss);
+ }
}
@SuppressWarnings("unchecked")
}
@Override
- public ContentProvider getProvider() {
+ public JcrContentProvider getProvider() {
return provider;
}
/*
* TYPING
*/
+
+ static Object convertSingleValue(Value value) throws JcrException, IllegalArgumentException {
+ try {
+ switch (value.getType()) {
+ case PropertyType.STRING:
+ return value.getString();
+ case PropertyType.DOUBLE:
+ return (Double) value.getDouble();
+ case PropertyType.LONG:
+ return (Long) value.getLong();
+ case PropertyType.BOOLEAN:
+ return (Boolean) value.getBoolean();
+ case PropertyType.DATE:
+ Calendar calendar = value.getDate();
+ return calendar.toInstant();
+ case PropertyType.BINARY:
+ throw new IllegalArgumentException("Binary is not supported as an attribute");
+ default:
+ return value.getString();
+ }
+ } catch (RepositoryException e) {
+ throw new JcrException("Cannot convert " + value + " to an object.", e);
+ }
+ }
+
+ static Value convertSingleObject(ValueFactory factory, Object value) {
+ if (value instanceof String string) {
+ return factory.createValue(string);
+ } else if (value instanceof Double dbl) {
+ return factory.createValue(dbl);
+ } else if (value instanceof Float flt) {
+ return factory.createValue(flt);
+ } else if (value instanceof Long lng) {
+ return factory.createValue(lng);
+ } else if (value instanceof Integer intg) {
+ return factory.createValue(intg);
+ } else if (value instanceof Boolean bool) {
+ return factory.createValue(bool);
+ } else if (value instanceof Instant instant) {
+ GregorianCalendar calendar = new GregorianCalendar();
+ calendar.setTime(Date.from(instant));
+ return factory.createValue(calendar);
+ } else {
+ // TODO or use String by default?
+ throw new IllegalArgumentException("Unsupported value " + value.getClass());
+ }
+ }
+
+ @Override
+ public Class<?> getType(QName key) {
+ Node node = getJcrNode();
+ String p = NamespaceUtils.toFullyQualified(key);
+ try {
+ if (node.hasProperty(p)) {
+ Property property = node.getProperty(p);
+ return switch (property.getType()) {
+ case PropertyType.STRING:
+ case PropertyType.NAME:
+ case PropertyType.PATH:
+ case PropertyType.DECIMAL:
+ yield String.class;
+ case PropertyType.LONG:
+ yield Long.class;
+ case PropertyType.DOUBLE:
+ yield Double.class;
+ case PropertyType.BOOLEAN:
+ yield Boolean.class;
+ case PropertyType.DATE:
+ yield Instant.class;
+ case PropertyType.WEAKREFERENCE:
+ case PropertyType.REFERENCE:
+ yield UUID.class;
+ default:
+ yield Object.class;
+ };
+ } else {
+ // TODO does it make sense?
+ return Object.class;
+ }
+ } catch (RepositoryException e) {
+ throw new JcrException("Cannot get type of property " + p + " of " + jcrPath + " in " + jcrWorkspace, e);
+ }
+ }
+
@Override
public List<QName> getContentClasses() {
try {
-// Node node = getJcrNode();
-// List<QName> res = new ArrayList<>();
-// res.add(nodeTypeToQName(node.getPrimaryNodeType()));
-// for (NodeType mixin : node.getMixinNodeTypes()) {
-// res.add(nodeTypeToQName(mixin));
-// }
-// return res;
Node context = getJcrNode();
List<QName> res = new ArrayList<>();
secondaryTypes.add(nodeTypeToQName(superType));
}
}
-// // entity type
-// if (context.isNodeType(EntityType.entity.get())) {
-// if (context.hasProperty(EntityNames.ENTITY_TYPE)) {
-// String entityTypeName = context.getProperty(EntityNames.ENTITY_TYPE).getString();
-// if (byType.containsKey(entityTypeName)) {
-// types.add(entityTypeName);
-// }
-// }
-// }
res.addAll(secondaryTypes);
return res;
} catch (RepositoryException e) {
private QName nodeTypeToQName(NodeType nodeType) {
String name = nodeType.getName();
return NamespaceUtils.parsePrefixedName(provider, name);
- //return QName.valueOf(name);
+ // return QName.valueOf(name);
}
- @Override
- public int getSiblingIndex() {
- return Jcr.getIndex(getJcrNode());
+ /*
+ * COMMON UTILITIES
+ */
+ protected Session getJcrSession() {
+ return provider.getJcrSession(getSession(), jcrWorkspace);
+ }
+
+ protected Node getJcrNode() {
+ try {
+ if (caching) {
+ synchronized (this) {
+ if (lastRetrievingThread != Thread.currentThread()) {
+ cachedNode = getJcrSession().getNode(jcrPath);
+ lastRetrievingThread = Thread.currentThread();
+ }
+ return cachedNode;
+ }
+ } else {
+ return getJcrSession().getNode(jcrPath);
+ }
+ } catch (RepositoryException e) {
+ throw new JcrException("Cannot retrieve " + jcrPath + " from workspace " + jcrWorkspace, e);
+ }
}
/*
if (contentSession == null)
throw new IllegalArgumentException(
"Cannot adapt " + node + " to content, because it was not loaded from a content session");
- return contentSession.get(ContentUtils.SLASH + CmsConstants.SYS_WORKSPACE + node.getPath());
+ return contentSession.get(Content.ROOT_PATH + CmsConstants.SYS_WORKSPACE + node.getPath());
} catch (RepositoryException e) {
throw new JcrException("Cannot adapt " + node + " to a content", e);
}
}
+ /*
+ * CONTENT ITERATOR
+ */
+
+ class JcrContentIterator implements Iterator<Content> {
+ private final NodeIterator nodeIterator;
+ // we keep track in order to be able to delete it
+ private JcrContent current = null;
+
+ protected JcrContentIterator(NodeIterator nodeIterator) {
+ this.nodeIterator = nodeIterator;
+ }
+
+ @Override
+ public boolean hasNext() {
+ return nodeIterator.hasNext();
+ }
+
+ @Override
+ public Content next() {
+ current = new JcrContent(getSession(), provider, jcrWorkspace, Jcr.getPath(nodeIterator.nextNode()));
+ return current;
+ }
+
+ @Override
+ public void remove() {
+ if (current != null) {
+ Jcr.remove(current.getJcrNode());
+ }
+ }
+
+ }
+
}
this.jcrRepository = jcrRepository;
}
+ @Override
+ public String getMountPath() {
+ return mountPath;
+ }
+
+ /*
+ * READ
+ */
+
@Override
public ProvidedContent get(ProvidedSession contentSession, String relativePath) {
- String jcrPath = "/" + relativePath;
- return new JcrContent(contentSession, this, jcrWorkspace, jcrPath);
+ return new JcrContent(contentSession, this, jcrWorkspace, toJcrPath(relativePath));
}
@Override
public boolean exists(ProvidedSession contentSession, String relativePath) {
- String jcrWorkspace = ContentUtils.getParentPath(mountPath)[1];
- String jcrPath = "/" + relativePath;
+ String jcrPath = ContentUtils.SLASH + relativePath;
return new JcrContent(contentSession, this, jcrWorkspace, jcrPath).exists();
}
- public Session getJcrSession(ProvidedSession contentSession, String jcrWorkspace) {
+ protected JcrSessionAdapter getJcrSessionAdapter(ProvidedSession contentSession) {
JcrSessionAdapter sessionAdapter = sessionAdapters.get(contentSession);
if (sessionAdapter == null) {
final JcrSessionAdapter newSessionAdapter = new JcrSessionAdapter(jcrRepository, contentSession,
contentSession.onClose().thenAccept((s) -> newSessionAdapter.close());
sessionAdapter = newSessionAdapter;
}
+ return sessionAdapter;
+ }
+ public Session getJcrSession(ProvidedSession contentSession, String jcrWorkspace) {
+ JcrSessionAdapter sessionAdapter = getJcrSessionAdapter(contentSession);
Session jcrSession = sessionAdapter.getSession(jcrWorkspace);
return jcrSession;
}
return getJcrSession(((ProvidedContent) content).getSession(), jcrWorkspace);
}
+ /*
+ * WRITE
+ */
+ Node openForEdit(ProvidedSession contentSession, String jcrWorkspace, String jcrPath) {
+ try {
+ if (contentSession.isEditing()) {
+ JcrSessionAdapter sessionAdapter = getJcrSessionAdapter(contentSession);
+ return sessionAdapter.openForEdit(jcrWorkspace, jcrPath);
+ } else {
+ return getJcrSession(contentSession, jcrWorkspace).getNode(jcrPath);
+ }
+ } catch (RepositoryException e) {
+ throw new JcrException("Cannot open for edit " + jcrPath + " in workspace " + jcrWorkspace, e);
+ }
+ }
+
@Override
- public String getMountPath() {
- return mountPath;
+ public void persist(ProvidedSession contentSession) {
+ try {
+ JcrSessionAdapter sessionAdapter = getJcrSessionAdapter(contentSession);
+ sessionAdapter.persist();
+ } catch (RepositoryException e) {
+ throw new JcrException("Cannot persist " + contentSession, e);
+ }
}
- public synchronized <T> T doInAdminSession(Function<Session, T> toDo) {
+ /*
+ * EDITING
+ */
+
+ @Override
+ public void openForEdit(ProvidedSession session, String relativePath) {
+ openForEdit(session, relativePath, toJcrPath(relativePath));
+ }
+
+ @Override
+ public void freeze(ProvidedSession session, String relativePath) {
try {
- return toDo.apply(adminSession);
- } finally {
- try {
- if (adminSession.hasPendingChanges())
- adminSession.save();
- } catch (RepositoryException e) {
- throw new JcrException("Cannot save admin session", e);
+ String jcrPath = toJcrPath(relativePath);
+ if (session.isEditing()) {
+ JcrSessionAdapter sessionAdapter = getJcrSessionAdapter(session);
+ sessionAdapter.freeze(jcrWorkspace, jcrPath);
}
+ } catch (RepositoryException e) {
+ throw new JcrException("Cannot freeze " + relativePath + " in workspace " + jcrWorkspace, e);
+ }
+ }
+
+ @Override
+ public boolean isOpenForEdit(ProvidedSession session, String relativePath) {
+ try {
+ String jcrPath = toJcrPath(relativePath);
+ JcrSessionAdapter sessionAdapter = getJcrSessionAdapter(session);
+ return sessionAdapter.isOpenForEdit(jcrWorkspace, jcrPath);
+ } catch (RepositoryException e) {
+ throw new JcrException(
+ "Cannot check whether " + relativePath + " is open for edit in workspace " + jcrWorkspace, e);
}
}
}
}
+
+ /*
+ * UTILITIES
+ */
+ /**
+ * Just adds a '/' so that it becomes an absolute JCR path within the JCR
+ * workspace of this provider.
+ */
+ private String toJcrPath(String relativePath) {
+ return ContentUtils.SLASH + relativePath;
+ }
+
+ /*
+ * TRANSITIONAL, WHILE MIGRATING FROM JCR TO ACR
+ */
+ @Deprecated
+ public synchronized <T> T doInAdminSession(Function<Session, T> toDo) {
+ try {
+ return toDo.apply(adminSession);
+ } finally {
+ try {
+ if (adminSession.hasPendingChanges())
+ adminSession.save();
+ } catch (RepositoryException e) {
+ throw new JcrException("Cannot save admin session", e);
+ }
+ }
+ }
+
}
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import javax.jcr.Node;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
+import javax.jcr.nodetype.NodeType;
+import javax.jcr.version.VersionManager;
import javax.security.auth.Subject;
import org.apache.jackrabbit.core.SessionImpl;
import org.argeo.api.acr.spi.ProvidedSession;
+import org.argeo.jcr.Jcr;
import org.argeo.jcr.JcrException;
import org.argeo.jcr.JcrUtils;
private Thread lastRetrievingThread = null;
+// private Thread writeThread;
+ private Map<String, Session> writeSessions = new HashMap<>();
+ /**
+ * Path of versionable nodes which have been modified during an edition cycle.
+ */
+ private Map<String, Set<String>> checkedInModified = new HashMap<>();
+ private Map<String, Set<String>> checkedOutModified = new HashMap<>();
+
public JcrSessionAdapter(Repository repository, ProvidedSession contentSession, Subject subject) {
this.repository = repository;
this.contentSession = contentSession;
Session session = threadSession.get(workspace);
if (session == null) {
- session = Subject.doAs(subject, (PrivilegedAction<Session>) () -> {
- try {
-// String username = CurrentUser.getUsername(subject);
-// SimpleCredentials credentials = new SimpleCredentials(username, new char[0]);
-// credentials.setAttribute(ProvidedSession.class.getName(), contentSession);
- Session sess = repository.login(workspace);
- // Jackrabbit specific:
- ((SessionImpl)sess).setAttribute(ProvidedSession.class.getName(), contentSession);
- return sess;
- } catch (RepositoryException e) {
- throw new IllegalStateException("Cannot log in to " + workspace, e);
- }
- });
+ session = login(workspace);
threadSession.put(workspace, session);
}
return session;
}
+ protected synchronized Session getWriteSession(String workspace) throws RepositoryException {
+ Session session = writeSessions.get(workspace);
+ if (session == null) {
+ session = login(workspace);
+ writeSessions.put(workspace, session);
+ } else {
+// if ((writeThread != Thread.currentThread()) && session.hasPendingChanges()) {
+// throw new IllegalStateException("Session " + contentSession + " is currently being written to");
+// }
+// writeThread = Thread.currentThread();
+ }
+ return session;
+ }
+
+ public synchronized Node openForEdit(String workspace, String jcrPath) throws RepositoryException {
+ Session session = getWriteSession(workspace);
+ Node node = session.getNode(jcrPath);
+ if (node.isNodeType(NodeType.MIX_SIMPLE_VERSIONABLE)) {
+ VersionManager versionManager = session.getWorkspace().getVersionManager();
+ if (versionManager.isCheckedOut(jcrPath)) {
+ if (!checkedOutModified.containsKey(workspace))
+ checkedOutModified.put(workspace, new TreeSet<>());
+ checkedOutModified.get(workspace).add(jcrPath);
+ } else {
+ if (!checkedInModified.containsKey(workspace))
+ checkedInModified.put(workspace, new TreeSet<>());
+ checkedInModified.get(workspace).add(jcrPath);
+ versionManager.checkout(jcrPath);
+ }
+ }
+ return node;
+ }
+
+ public synchronized Node freeze(String workspace, String jcrPath) throws RepositoryException {
+ Session session = getWriteSession(workspace);
+ Node node = session.getNode(jcrPath);
+ if (node.isNodeType(NodeType.MIX_SIMPLE_VERSIONABLE)) {
+ VersionManager versionManager = session.getWorkspace().getVersionManager();
+ if (versionManager.isCheckedOut(jcrPath)) {
+ versionManager.checkin(jcrPath);
+ }
+ }
+ return node;
+ }
+
+ public synchronized boolean isOpenForEdit(String workspace, String jcrPath) throws RepositoryException {
+ Session session = getWriteSession(workspace);
+ VersionManager versionManager = session.getWorkspace().getVersionManager();
+ return versionManager.isCheckedOut(jcrPath);
+ }
+
+ public synchronized void persist() throws RepositoryException {
+ for (String workspace : writeSessions.keySet()) {
+ Session session = writeSessions.get(workspace);
+ if (session == null) {
+// assert writeThread == null;
+ assert !checkedOutModified.containsKey(workspace);
+ assert !checkedInModified.containsKey(workspace);
+ return; // nothing to do
+ }
+ session.save();
+ VersionManager versionManager = session.getWorkspace().getVersionManager();
+ if (checkedOutModified.containsKey(workspace))
+ for (String jcrPath : checkedOutModified.get(workspace)) {
+ versionManager.checkpoint(jcrPath);
+ }
+ if (checkedInModified.containsKey(workspace))
+ for (String jcrPath : checkedInModified.get(workspace)) {
+ versionManager.checkin(jcrPath);
+ }
+ Jcr.logout(session);
+ }
+
+ for (Map<String, Session> m : threadSessions.values())
+ for (Session session : m.values())
+ session.refresh(true);
+// writeThread = null;
+ writeSessions.clear();
+ checkedOutModified.clear();
+ checkedInModified.clear();
+ }
+
+ protected Session login(String workspace) {
+ return Subject.doAs(subject, (PrivilegedAction<Session>) () -> {
+ try {
+// String username = CurrentUser.getUsername(subject);
+// SimpleCredentials credentials = new SimpleCredentials(username, new char[0]);
+// credentials.setAttribute(ProvidedSession.class.getName(), contentSession);
+ Session sess = repository.login(workspace);
+ // Jackrabbit specific:
+ ((SessionImpl) sess).setAttribute(ProvidedSession.class.getName(), contentSession);
+ return sess;
+ } catch (RepositoryException e) {
+ throw new IllegalStateException("Cannot log in to " + workspace, e);
+ }
+ });
+ }
+
}
projects / gpl / argeo-jcr.git / commitdiff