You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jackrabbit.apache.org by kw...@apache.org on 2020/10/15 10:10:30 UTC
[jackrabbit-filevault] branch master updated: JCRVLT-462 no
validation error for uncontained root nodes (#98)
This is an automated email from the ASF dual-hosted git repository.
kwin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/jackrabbit-filevault.git
The following commit(s) were added to refs/heads/master by this push:
new 9ea1d7d JCRVLT-462 no validation error for uncontained root nodes (#98)
9ea1d7d is described below
commit 9ea1d7dab32669b49507604b69b9f401e6602e65
Author: Konrad Windszus <kw...@apache.org>
AuthorDate: Thu Oct 15 12:10:25 2020 +0200
JCRVLT-462 no validation error for uncontained root nodes (#98)
JCRVLT-463 Mandatory child node missing: jcr:content [nt:base]
JCRVLT-461 Mandatory property ''{http://www.jcp.org/jcr/1.0}data'
missing in node with types [oak:Resource]
Refactor the node type validator so that the mandatory properties and
child nodes are only validated after all contributing files/folders have
been visited
---
vault-doc/src/site/markdown/docview.md | 6 +-
vault-doc/src/site/markdown/vaultfs.md | 30 +-
.../vault/validation/ValidationExecutor.java | 12 +-
.../jackrabbit/vault/validation/package-info.java | 2 +-
.../vault/validation/spi/JcrPathValidator.java | 20 +-
.../vault/validation/spi/ValidationMessage.java | 10 +-
.../impl/nodetype/DocViewPropertyValueFactory.java | 2 +
.../spi/impl/nodetype/JcrNodeTypeMetaData.java | 75 +++
.../spi/impl/nodetype/JcrNodeTypeMetaDataImpl.java | 648 +++++++++++++++++++++
.../nodetype/NamespaceExceptionInNodeName.java} | 23 +-
.../spi/impl/nodetype/NodeNameAndType.java | 117 ----
.../spi/impl/nodetype/NodeTypeManagerProvider.java | 41 +-
.../spi/impl/nodetype/NodeTypeValidator.java | 531 +++++++----------
.../impl/nodetype/NodeTypeValidatorFactory.java | 7 +-
.../OnDemandRegisterNamespaceResolverWrapper.java | 61 ++
.../vault/validation/spi/package-info.java | 2 +-
.../vault/validation/ValidationExecutorTest.java | 8 +-
.../impl/nodetype/JcrNodeTypeMetaDataImplTest.java | 411 +++++++++++++
.../spi/impl/nodetype/NodeTypeValidatorTest.java | 70 ++-
.../resources/simple-restricted-nodetypes.cnd} | 26 +-
20 files changed, 1588 insertions(+), 514 deletions(-)
diff --git a/vault-doc/src/site/markdown/docview.md b/vault-doc/src/site/markdown/docview.md
index a1a2dcd..5dd00cd 100644
--- a/vault-doc/src/site/markdown/docview.md
+++ b/vault-doc/src/site/markdown/docview.md
@@ -24,8 +24,8 @@ Overview
----------
FileVault uses a slightly different version of the Document View specified by [JCR 2.0][jcr-docview].
-In general all nodes can cannot be serialized as plain directories or as plain files are either
-serialized into DocView XML file. If the node can only be partially mapped to a directory or file,
+In general all nodes that cannot be serialized as plain directories or as plain files are
+serialized into DocView XML files. If the node can only be partially mapped to a directory or file,
it will be accompanied with a `.content.xml` containing the residual content.
For example, a _full coverage_ content tree, starting at the node `example` will be serialized into
@@ -74,6 +74,8 @@ property-value := [ "{" property-type "}" ] ( value | "[" [ value { "," value }
```
If no type is specified, it defaults to [STRING][pt-string].
+As types all arguments accepted by [PropertyType.valueFromName(String)](https://docs.adobe.com/docs/en/spec/jsr170/javadocs/jcr-2.0/javax/jcr/PropertyType.html#valueFromName(java.lang.String)) are valid.
+This is all strings defined by the constants whose names start with `TYPENAME_` in [PropertyType](https://docs.adobe.com/docs/en/spec/jsr170/javadocs/jcr-2.0/javax/jcr/PropertyType.html).
Examples:
diff --git a/vault-doc/src/site/markdown/vaultfs.md b/vault-doc/src/site/markdown/vaultfs.md
index e13b6a5..641e75e 100644
--- a/vault-doc/src/site/markdown/vaultfs.md
+++ b/vault-doc/src/site/markdown/vaultfs.md
@@ -87,6 +87,7 @@ they aggregate an entire subtree. for example the complete serialization of a `n
The following repository structure:
+```
+ nodetypes [nt:unstructured]
+ nt1 [nt:nodeType]
+ jcr:propertyDefinition [nt:propertyDefinition]
@@ -94,18 +95,22 @@ The following repository structure:
+ jcr:childNodeDefinition [nt:childNodeDefinition]
+ nt2 [nt:nodeType]
...
+```
could be mapped to:
+```
`- nodetypes
|- nt1.cnd
`- nt2.cnd
+```
#### Generic aggregates
generic aggregates cover a part of a content subtree, hence they have not a full coverage. they always consist at least of a primary artifact and a directory artifact. examples of those are the aggregation of a `cq:Page` structure or of `nt:unstructured` nodes.
the following repository structure:
+```
+ en [cq:Page]
+ jcr:content [cq:Content]
+ about [cq:Page]
@@ -114,10 +119,12 @@ the following repository structure:
+ image.jpg
+ solutions [cq:Page
+ jcr:content [cq:Content]
+```
are mapped to:
- `- en
+```
+ - `en
|- .content.xml
|- about
| |- _jcr_content
@@ -126,11 +133,13 @@ are mapped to:
| `- .content.xml
`- solution
`- .content.xml
+```
the example above just excluded some direct child nodes of the aggregate root from the aggregation (with the exception of the `image.jpg` node). but this could be more complicated.
overlapping example:
+```
+ apps [nt:unstructured]
+ example [nt:unstructured]
+ components [nt:unstructured]
@@ -138,9 +147,11 @@ overlapping example:
+ dialog [cq:Dialog]
...
+ default.jsp [nt:file]
+```
is be mapped to:
+```
`- apps
|- .content.xml
`- example
@@ -151,6 +162,7 @@ is be mapped to:
|- .content.xml
|- dialog.xml
`- default.jsp
+```
this example has 6 aggregates:
@@ -174,6 +186,7 @@ but to keep the mapping lean, those properties are not part of the file aggregat
example:
+```
+ foo [nt:folder]
+ example.jsp [nt:file]
- jcr:created ...
@@ -181,6 +194,7 @@ example:
- jcr:data
- jcr:lastModified
- jcr:mimeType
+```
is mapped to:
@@ -231,30 +245,36 @@ example (although this is probably very rare):
is mapped to:
+```
`- foo
|- .content.xml
`- bar
|- 0001
- | |- data1.bin
- | `- data2.bin
+ | |- data1.binary
+ | `- data2.binary
`- 0002
- |- data1.bin
- `- data2.bin
+ |- data1.binary
+ `- data2.binary
+```
#### Resource Nodes
there are some cases where `nt:resource` like structures are used that are not held below a `nt:file` node.
+```
+ foo [nt:unstructured]
+ cq:content [nt:resource]
- jcr:mimeType "image/jpg"
- jcr:data
- jcr:lastModified
+```
this is mapped to:
+```
`- foo
|- .content.xml
`- _cq_content.jpg
+```
where as the mimetype and modification date can be recorded in the primary artifact. possible other properties like `jcr:uuid` etc would go to the parent aggregate.
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/ValidationExecutor.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/ValidationExecutor.java
index 8117354..35254d9 100644
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/ValidationExecutor.java
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/ValidationExecutor.java
@@ -30,6 +30,7 @@ import java.util.stream.Collectors;
import org.apache.commons.io.FilenameUtils;
import org.apache.jackrabbit.vault.util.Constants;
import org.apache.jackrabbit.vault.util.PlatformNameFormat;
+import org.apache.jackrabbit.vault.util.Text;
import org.apache.jackrabbit.vault.validation.impl.util.EnhancedBufferedInputStream;
import org.apache.jackrabbit.vault.validation.impl.util.ResettableInputStream;
import org.apache.jackrabbit.vault.validation.impl.util.ValidatorException;
@@ -63,6 +64,7 @@ import org.slf4j.LoggerFactory;
*/
public final class ValidationExecutor {
+ public static final String EXTENSION_BINARY = ".binary";
private final Map<String, DocumentViewXmlValidator> documentViewXmlValidators;
private final Map<String, NodePathValidator> nodePathValidators;
private final Map<String, GenericJcrDataValidator> genericJcrDataValidators;
@@ -270,6 +272,7 @@ public final class ValidationExecutor {
Map<String, Integer> nodePathsAndLineNumbers = new LinkedHashMap<>();
Collection<ValidationViolation> enrichedMessages = new LinkedList<>();
+ boolean isDocViewXml = true;
if (input != null) {
InputStream currentInput = input;
ResettableInputStream resettableInputStream = null;
@@ -299,6 +302,7 @@ public final class ValidationExecutor {
// convert file name to node path
String nodePath = filePathToNodePath(filePath);
log.debug("Found non-docview node '{}'", nodePath);
+ isDocViewXml = false;
nodePathsAndLineNumbers.put(nodePath, 0);
}
} catch (RuntimeException e) {
@@ -322,7 +326,7 @@ public final class ValidationExecutor {
// generate node context
NodeContext nodeContext = new NodeContextImpl(nodePathsAndLineNumbers.keySet().iterator().next(), filePath, basePath);
for (Map.Entry<String, JcrPathValidator> entry : jcrPathValidators.entrySet()) {
- Collection<ValidationMessage> messages = entry.getValue().validateJcrPath(nodeContext, input == null);
+ Collection<ValidationMessage> messages = entry.getValue().validateJcrPath(nodeContext, input == null, isDocViewXml);
if (messages != null && !messages.isEmpty()) {
enrichedMessages.addAll(ValidationViolation.wrapMessages(entry.getKey(), messages, filePath, basePath, null, 0, 0));
}
@@ -338,10 +342,16 @@ public final class ValidationExecutor {
*/
public static @NotNull String filePathToNodePath(@NotNull Path filePath) {
String platformPath = FilenameUtils.separatorsToUnix(filePath.toString());
+ // treat https://jackrabbit.apache.org/filevault/vaultfs.html#Binary_Properties specially
+ if (platformPath.endsWith(EXTENSION_BINARY)) {
+ platformPath = Text.getRelativeParent(platformPath, 1);
+ }
String repositoryPath = PlatformNameFormat.getRepositoryPath(platformPath, true);
if (!repositoryPath.isEmpty()) {
// make repository path absolute by prefixing it with "/" in case it is not the root node path itself
repositoryPath = "/" + repositoryPath;
+ } else {
+ repositoryPath = "/";
}
return repositoryPath;
}
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/package-info.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/package-info.java
index 6521ca2..0d76523 100644
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/package-info.java
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/package-info.java
@@ -17,7 +17,7 @@
/**
* The FileVault validation framework API. Provides classes to execute validations on FileVault packages.
*/
-@Version("2.0.0")
+@Version("2.1.0")
package org.apache.jackrabbit.vault.validation;
import org.osgi.annotation.versioning.Version;
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/JcrPathValidator.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/JcrPathValidator.java
index 6a2cd9f..1ca824b 100644
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/JcrPathValidator.java
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/JcrPathValidator.java
@@ -25,9 +25,8 @@ import org.osgi.annotation.versioning.ProviderType;
/**
- * Validator interface for validating file paths for files and folders
- * below jcr_root.
- * Called after {@link GenericJcrDataValidator}.
+ * Validator interface for validating file paths for files and folders below {@code jcr_root}.
+ * Called after {@link GenericJcrDataValidator} and after {@link DocumentViewXmlValidator}.
* In contrast to {@link NodePathValidator} only called once per file and folder (even if those are covering multiple node paths).
*/
@ProviderType
@@ -37,7 +36,7 @@ public interface JcrPathValidator extends Validator {
*
* @param filePath the relative file/folder path to the jcr_root directory
* @return validation messages or {@code null}
- * @deprecated Use {@link #validateJcrPath(NodeContext, boolean)} instead.
+ * @deprecated Use {@link #validateJcrPath(NodeContext, boolean, boolean)} instead.
*/
@Deprecated
default @Nullable Collection<ValidationMessage> validateJcrPath(@NotNull Path filePath) {
@@ -50,9 +49,22 @@ public interface JcrPathValidator extends Validator {
* @param nodeContext the meta information about the node given through this file/folder
* @param isFolder {@code true} in case it is a folder, otherwise {@code false}
* @return validation messages or {@code null}
+ * @deprecated Use {@link #validateJcrPath(NodeContext, boolean, boolean)} instead.
*/
+ @Deprecated
default @Nullable Collection<ValidationMessage> validateJcrPath(@NotNull NodeContext nodeContext, boolean isFolder) {
return validateJcrPath(nodeContext.getFilePath());
}
+ /**
+ * Called for each file/folder below jcr_root.
+ *
+ * @param nodeContext the meta information about the node given through this file/folder
+ * @param isFolder {@code true} in case it is a folder, otherwise {@code false}
+ * @param isDocViewXml {@code true} in case {@code isFolder} is {@code false} and the file is a Document View XML file, otherwise {@code false}
+ * @return validation messages or {@code null}
+ */
+ default @Nullable Collection<ValidationMessage> validateJcrPath(@NotNull NodeContext nodeContext, boolean isFolder, boolean isDocViewXml) {
+ return validateJcrPath(nodeContext, isFolder);
+ }
}
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/ValidationMessage.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/ValidationMessage.java
index 3267442..aaa3254 100644
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/ValidationMessage.java
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/ValidationMessage.java
@@ -55,6 +55,14 @@ public class ValidationMessage {
this(severity, message, nodePath, filePath, basePath, 0, 0, throwable);
}
+ public ValidationMessage(@NotNull ValidationMessageSeverity severity, @NotNull String message, @NotNull NodeContext nodeContext) {
+ this(severity, message, nodeContext.getNodePath(), nodeContext.getFilePath(), nodeContext.getBasePath(), 0, 0, null);
+ }
+
+ public ValidationMessage(@NotNull ValidationMessageSeverity severity, @NotNull String message, @NotNull NodeContext nodeContext, Throwable throwable) {
+ this(severity, message, nodeContext.getNodePath(), nodeContext.getFilePath(), nodeContext.getBasePath(), 0, 0, throwable);
+ }
+
public ValidationMessage(@NotNull ValidationMessageSeverity severity, @NotNull String message, Path filePath, Path basePath, int line, int column, Throwable throwable) {
this(severity, message, null, filePath, basePath, line, column, throwable);
}
@@ -183,6 +191,4 @@ public class ValidationMessage {
+ (throwable != null ? "throwable=" + throwable + ", " : "") + (nodePath != null ? "nodePath=" + nodePath + ", " : "")
+ (filePath != null ? "filePath=" + filePath + ", " : "") + (basePath != null ? "basePath=" + basePath : "") + "]";
}
-
-
}
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/DocViewPropertyValueFactory.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/DocViewPropertyValueFactory.java
index a9704ba..f8495a8 100644
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/DocViewPropertyValueFactory.java
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/DocViewPropertyValueFactory.java
@@ -27,6 +27,7 @@ import javax.jcr.ValueFormatException;
import org.apache.jackrabbit.value.ValueFactoryImpl;
import org.apache.jackrabbit.vault.util.DocViewProperty;
+/** Creates JCR values from DocViewProperties */
public class DocViewPropertyValueFactory {
private final ValueFactory valueFactory;
@@ -36,6 +37,7 @@ public class DocViewPropertyValueFactory {
private Value getValue(String value, int type) throws ValueFormatException {
if (type == PropertyType.UNDEFINED) {
+ // simulate behaviour of DocViewProperty.apply(...) which leverages setProperty(String name, String value)
type = PropertyType.STRING;
}
return valueFactory.createValue(value, type);
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/JcrNodeTypeMetaData.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/JcrNodeTypeMetaData.java
new file mode 100644
index 0000000..ea41212
--- /dev/null
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/JcrNodeTypeMetaData.java
@@ -0,0 +1,75 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.jackrabbit.vault.validation.spi.impl.nodetype;
+
+import java.util.Collection;
+import java.util.Optional;
+
+import javax.jcr.ItemNotFoundException;
+import javax.jcr.NamespaceException;
+import javax.jcr.RepositoryException;
+import javax.jcr.Value;
+import javax.jcr.nodetype.ConstraintViolationException;
+import javax.jcr.nodetype.NoSuchNodeTypeException;
+
+import org.apache.jackrabbit.jcr2spi.nodetype.EffectiveNodeTypeProvider;
+import org.apache.jackrabbit.jcr2spi.nodetype.ItemDefinitionProvider;
+import org.apache.jackrabbit.jcr2spi.nodetype.NodeTypeDefinitionProvider;
+import org.apache.jackrabbit.spi.Name;
+import org.apache.jackrabbit.spi.commons.conversion.IllegalNameException;
+import org.apache.jackrabbit.spi.commons.conversion.NamePathResolver;
+import org.apache.jackrabbit.spi.commons.conversion.NameResolver;
+import org.apache.jackrabbit.vault.fs.api.WorkspaceFilter;
+import org.apache.jackrabbit.vault.validation.spi.NodeContext;
+import org.apache.jackrabbit.vault.validation.spi.ValidationMessage;
+import org.apache.jackrabbit.vault.validation.spi.ValidationMessageSeverity;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface JcrNodeTypeMetaData {
+
+ void addProperty(@NotNull NodeContext nodeContext, @NotNull NamePathResolver namePathResolver, @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider,
+ @NotNull NodeTypeDefinitionProvider nodeTypeDefinitionProvider, @NotNull ItemDefinitionProvider itemDefinitionProvider,
+ @NotNull ValidationMessageSeverity severity, String name, boolean isMultiValue, Value... values) throws RepositoryException;
+ @NotNull JcrNodeTypeMetaData addImplicitChildNode(@NotNull NameResolver nameResolver,
+ @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider, @NotNull NodeTypeDefinitionProvider nodeTypeDefinitionProvider,
+ @NotNull ItemDefinitionProvider itemDefinitionProvider, @NotNull NodeContext nodeContext, @NotNull Name implicitNodeType)
+ throws RepositoryException;
+ @NotNull JcrNodeTypeMetaData addChildNode(@NotNull NameResolver nameResolver, @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider,
+ @NotNull NodeTypeDefinitionProvider nodeTypeDefinitionProvider, @NotNull ItemDefinitionProvider itemDefinitionProvider,
+ @NotNull ValidationMessageSeverity severity, @NotNull NodeContext nodeContext, @NotNull String primaryType, String... mixinTypes)
+ throws RepositoryException, NamespaceExceptionInNodeName;
+ @NotNull JcrNodeTypeMetaData addUnknownChildNode(@NotNull NameResolver nameResolver, @NotNull String name) throws IllegalNameException, NamespaceException;
+
+ // navigate
+ @NotNull Collection<@NotNull ? extends JcrNodeTypeMetaData> getChildren();
+ Optional<JcrNodeTypeMetaData> getNode(NamePathResolver nameResolver, String path)
+ throws ItemNotFoundException, RepositoryException;
+ @NotNull JcrNodeTypeMetaData getOrCreateNode(NamePathResolver nameResolver, String path) throws RepositoryException;
+
+ @NotNull Collection<ValidationMessage> finalizeValidation(@NotNull NamePathResolver nameResolver,
+ @NotNull ValidationMessageSeverity severity, @NotNull WorkspaceFilter filter) throws NamespaceException;
+ void fetchAndClearValidationMessages(Collection<ValidationMessage> messages);
+ @NotNull Name getPrimaryNodeType();
+ String getQualifiedPath(NamePathResolver resolver) throws NamespaceException;
+ void setNodeTypes(@NotNull NameResolver nameResolver, @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider,
+ @Nullable String primaryType, String... mixinTypes)
+ throws IllegalNameException, ConstraintViolationException, NoSuchNodeTypeException, NamespaceException;
+ void setUnknownNodeTypes();
+
+
+}
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/JcrNodeTypeMetaDataImpl.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/JcrNodeTypeMetaDataImpl.java
new file mode 100644
index 0000000..ab3835a
--- /dev/null
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/JcrNodeTypeMetaDataImpl.java
@@ -0,0 +1,648 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.jackrabbit.vault.validation.spi.impl.nodetype;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import javax.jcr.NamespaceException;
+import javax.jcr.PropertyType;
+import javax.jcr.RepositoryException;
+import javax.jcr.Value;
+import javax.jcr.nodetype.ConstraintViolationException;
+import javax.jcr.nodetype.NoSuchNodeTypeException;
+
+import org.apache.jackrabbit.jcr2spi.nodetype.EffectiveNodeType;
+import org.apache.jackrabbit.jcr2spi.nodetype.EffectiveNodeTypeProvider;
+import org.apache.jackrabbit.jcr2spi.nodetype.ItemDefinitionProvider;
+import org.apache.jackrabbit.jcr2spi.nodetype.NodeTypeDefinitionProvider;
+import org.apache.jackrabbit.spi.Name;
+import org.apache.jackrabbit.spi.Path;
+import org.apache.jackrabbit.spi.Path.Element;
+import org.apache.jackrabbit.spi.QNodeDefinition;
+import org.apache.jackrabbit.spi.QNodeTypeDefinition;
+import org.apache.jackrabbit.spi.QPropertyDefinition;
+import org.apache.jackrabbit.spi.QValue;
+import org.apache.jackrabbit.spi.QValueFactory;
+import org.apache.jackrabbit.spi.commons.conversion.IllegalNameException;
+import org.apache.jackrabbit.spi.commons.conversion.MalformedPathException;
+import org.apache.jackrabbit.spi.commons.conversion.NamePathResolver;
+import org.apache.jackrabbit.spi.commons.conversion.NameResolver;
+import org.apache.jackrabbit.spi.commons.name.NameConstants;
+import org.apache.jackrabbit.spi.commons.name.NameFactoryImpl;
+import org.apache.jackrabbit.spi.commons.name.PathBuilder;
+import org.apache.jackrabbit.spi.commons.name.PathFactoryImpl;
+import org.apache.jackrabbit.spi.commons.nodetype.constraint.ValueConstraint;
+import org.apache.jackrabbit.spi.commons.value.QValueFactoryImpl;
+import org.apache.jackrabbit.spi.commons.value.ValueFormat;
+import org.apache.jackrabbit.vault.fs.api.WorkspaceFilter;
+import org.apache.jackrabbit.vault.util.Text;
+import org.apache.jackrabbit.vault.validation.spi.NodeContext;
+import org.apache.jackrabbit.vault.validation.spi.ValidationMessage;
+import org.apache.jackrabbit.vault.validation.spi.ValidationMessageSeverity;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/** This class encapsulates node type related data of a node. It uses expanded names/paths internally. */
+public class JcrNodeTypeMetaDataImpl implements JcrNodeTypeMetaData {
+
+ static final String EXCEPTION_MESSAGE_INVALID_NAME = "Invalid %s '%s': %s";
+ static final String CONSTRAINT_PROPERTY_VALUE = "Value constraint violation: %s";
+ static final String CONSTRAINT_PROPERTY_PROTECTED = "Property is protected!";
+ static final String CONSTRAINT_PROPERTY_AUTO_CREATED = "Property is auto-created and can not be manually added";
+ static final String CONSTRAINT_PROPERTY_NOT_ALLOWED = "No applicable property definition found for name and type!";
+ static final String CONSTRAINT_CHILD_NODE_AUTO_CREATED = "Node is auto-created and can not be manually added";
+ static final String CONSTRAINT_CHILD_NODE_PROTECTED = "Node is protected and can not be manually added";
+ static final String CONSTRAINT_MIXIN_TYPE_AS_PRIMARY_TYPE = "Given node type is a mixin and cannot be used as primary node type.";
+ static final String CONSTRAINT_ABSTRACT_TYPE_AS_PRIMARY_TYPE = "Given node type is abstract and cannot be used as primary node type.";
+ static final String CONSTRAINT_CHILD_NODE_NOT_ALLOWED = "Node type does not allow arbitrary child nodes and does not allow this specific name and node type either!";
+
+ static final String MESSAGE_CHILD_NODE_OF_NOT_CONTAINED_PARENT_POTENTIALLY_NOT_ALLOWED = "Node '%s [%s]' is not allowed as child of not contained node with potential default types '[%s]': %s";
+ static final String MESSAGE_CHILD_NODE_NOT_ALLOWED = "Node '%s [%s]' is not allowed as child of node with types [%s]: %s";
+ static final String MESSAGE_PROPERTY_OF_NOT_CONTAINED_PARENT_POTENTIALLY_NOT_ALLOWED = null;
+ static final String MESSAGE_PROPERTY_NOT_ALLOWED = "Property '%s' [%s] is not allowed in node with potential default types [%s]: %s";
+ static final String MESSAGE_MANDATORY_CHILD_NODE_MISSING = "Mandatory child node missing: %s inside node with types [%s] at %s";
+ static final String MESSAGE_MANDATORY_UNCONTAINED_CHILD_NODE_MISSING = "Mandatory child node missing: %s inside node with types [%s] at %s (outside of filter rules)";
+ static final String MESSAGE_MANDATORY_PROPERTY_MISSING = "Mandatory property '%s' missing in node with types [%s] at %s";
+ static final String MESSAGE_MANDATORY_PROPERTY_WITH_WRONG_TYPE = "Mandatory property '%s' has type '%s' while it should have '%s' in node with types [%s] at %s";
+
+ private static final Collection<Name> ALLOWED_PROTECTED_PROPERTIES = Arrays.asList(NameConstants.JCR_PRIMARYTYPE,
+ NameConstants.JCR_MIXINTYPES);
+
+ private static final Name NT_REP_POLICY = NameFactoryImpl.getInstance().create(Name.NS_REP_URI, "Policy");
+ private static final Name NT_REP_AUTHORIZABLE = NameFactoryImpl.getInstance().create(Name.NS_REP_URI, "Authorizable");
+ private static final QValueFactory QVALUE_FACTORY = QValueFactoryImpl.getInstance();
+
+ private final @NotNull Name name;
+ private @Nullable Name primaryNodeType; // the effectiveNodeType does not remember which one was the primary one!
+ private @Nullable EffectiveNodeType effectiveNodeType;
+ private final @NotNull Map<Name, Integer> propertyTypesByName;
+ private final @NotNull Map<Name, JcrNodeTypeMetaDataImpl> childNodesByName;
+ private final @Nullable JcrNodeTypeMetaDataImpl parentNode;
+ private final Collection<ValidationMessage> messages;
+ private final boolean isAuthenticationOrAuthorizationContext;
+ private final boolean isImplicit; // if this is true, the node type is set implicitly (not explicitly set in package, used as is in the
+ // repository)
+ private boolean isValidationDone;
+
+ private JcrNodeTypeMetaDataImpl(@NotNull Name name, @Nullable Name primaryNodeType, @Nullable EffectiveNodeType effectiveNodeType,
+ JcrNodeTypeMetaDataImpl parentNode, boolean isAuthenticationOrAuthorizationContext, boolean isImplicit) {
+ super();
+ this.name = name; // fully namespaced (taking into account local namespace declaration for Docview XML)
+ this.primaryNodeType = primaryNodeType;
+ this.effectiveNodeType = effectiveNodeType;
+ this.parentNode = parentNode;
+ this.propertyTypesByName = new HashMap<>();
+ this.childNodesByName = new HashMap<>();
+ this.messages = new ArrayList<>();
+ this.isAuthenticationOrAuthorizationContext = isAuthenticationOrAuthorizationContext;
+ this.isImplicit = isImplicit;
+ this.isValidationDone = false;
+ }
+
+ @Override
+ public String toString() {
+ return "JcrNodeTypeMetaDataImpl [" + "name=" + name + ", "
+ + "effectiveNodeType=" + effectiveNodeType + ", "
+ + "propertyTypesByName=" + propertyTypesByName + ", "
+ + "childNodes=" + childNodesByName.keySet() + ", "
+ // + "parentNode path="+(parentNode != null ? + parentNode.getPath() + ", " : "")
+ + (messages != null ? "messages=" + messages + ", " : "")
+ + "isAuthenticationOrAuthorizationContext=" + isAuthenticationOrAuthorizationContext + "]";
+ }
+
+ @Override
+ public void setUnknownNodeTypes() {
+ this.primaryNodeType = null;
+ this.effectiveNodeType = null;
+ }
+
+ @Override
+ public void setNodeTypes(@NotNull NameResolver nameResolver,
+ @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider, @NotNull String primaryType, String... mixinTypes)
+ throws IllegalNameException, ConstraintViolationException, NoSuchNodeTypeException, NamespaceException {
+ List<Name> types = getTypes(nameResolver, primaryType, mixinTypes);
+ if (effectiveNodeType == null || !effectiveNodeType.includesNodeTypes(types.toArray(new Name[0]))) {
+ this.primaryNodeType = types.get(0);
+ this.effectiveNodeType = effectiveNodeTypeProvider.getEffectiveNodeType(types.toArray(new Name[0]));
+ }
+ }
+
+ @Override
+ public Name getPrimaryNodeType() {
+ return primaryNodeType;
+ }
+
+ private static boolean isAclOrAuthorizableNodeType(EffectiveNodeType effectiveNodeType) {
+ return effectiveNodeType.includesNodeType(NT_REP_AUTHORIZABLE) || effectiveNodeType.includesNodeType(NT_REP_POLICY);
+ }
+
+ private enum NameType {
+ NODE_NAME("node name"), PRIMARY_TYPE("primary type"), MIXIN_TYPE("mixin type");
+
+ private final String label;
+
+ NameType(String label) {
+ this.label = label;
+ }
+
+ public String getLabel() {
+ return label;
+ }
+ }
+
+ private static @NotNull Name getQName(@NotNull NameResolver nameResolver, @NotNull String name, @NotNull NameType type)
+ throws IllegalNameException, NamespaceException {
+ try {
+ Name qName = nameResolver.getQName(name);
+ // was it a namespace which has been generated on demand before?
+ if (type != NameType.NODE_NAME
+ && qName.getNamespaceURI().startsWith(OnDemandRegisterNamespaceResolverWrapper.UNDECLARED_NAMESPACE_URI_PREFIX)) {
+ int posColon = name.indexOf(':');
+ // extract prefix
+ String prefix = name.substring(0, posColon);
+ throw new NamespaceException(prefix + ": is not a registered namespace prefix.");
+ }
+ return qName;
+ } catch (NamespaceException e) {
+ if (type == NameType.NODE_NAME) {
+ throw new NamespaceExceptionInNodeName(
+ String.format(EXCEPTION_MESSAGE_INVALID_NAME, type.getLabel(), name, e.getLocalizedMessage()), e);
+ }
+ throw new NamespaceException(String.format(EXCEPTION_MESSAGE_INVALID_NAME, type.getLabel(), name, e.getLocalizedMessage()), e);
+ } catch (IllegalNameException e) {
+ throw new IllegalNameException(String.format(EXCEPTION_MESSAGE_INVALID_NAME, type.getLabel(), name, e.getLocalizedMessage()),
+ e);
+ }
+ }
+
+ @Override
+ public @NotNull JcrNodeTypeMetaData addImplicitChildNode(@NotNull NameResolver nameResolver,
+ @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider,
+ @NotNull NodeTypeDefinitionProvider nodeTypeDefinitionProvider, @NotNull ItemDefinitionProvider itemDefinitionProvider,
+ @NotNull NodeContext nodeContext, @Nullable Name implicitNodeType) throws RepositoryException {
+ JcrNodeTypeMetaDataImpl childNode = addChildNode(nameResolver, effectiveNodeTypeProvider, nodeTypeDefinitionProvider,
+ itemDefinitionProvider, true, Text.getName(nodeContext.getNodePath()), implicitNodeType);
+ // now validate for validity
+ Optional<String> constraintViolation = childNode.validateAgainstParentNodeType(effectiveNodeType, nodeTypeDefinitionProvider,
+ itemDefinitionProvider);
+ if (constraintViolation.isPresent()) {
+ throw new IllegalArgumentException("The implicit node type is invalid here: " + constraintViolation.get());
+ }
+ return childNode;
+ }
+
+ @Override
+ public @NotNull JcrNodeTypeMetaData addUnknownChildNode(@NotNull NameResolver nameResolver, @NotNull String name)
+ throws IllegalNameException, NamespaceException {
+ return addUnknownChildNode(getQName(nameResolver, name, NameType.NODE_NAME));
+ }
+
+ private @NotNull JcrNodeTypeMetaDataImpl addUnknownChildNode(@NotNull Name name) throws IllegalNameException {
+ JcrNodeTypeMetaDataImpl childNode = new JcrNodeTypeMetaDataImpl(name, null, null, this, false, false);
+ childNodesByName.put(name, childNode);
+ return childNode;
+ }
+
+ @Override
+ public @NotNull JcrNodeTypeMetaData addChildNode(@NotNull NameResolver nameResolver,
+ @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider,
+ @NotNull NodeTypeDefinitionProvider nodeTypeDefinitionProvider, @NotNull ItemDefinitionProvider itemDefinitionProvider,
+ @NotNull ValidationMessageSeverity severity, @NotNull NodeContext nodeContext, @NotNull String primaryType,
+ String... mixinTypes)
+ throws IllegalNameException, NoSuchNodeTypeException, RepositoryException, NamespaceExceptionInNodeName {
+
+ List<Name> types = getTypes(nameResolver, primaryType, mixinTypes);
+ String nodeName = Text.getName(nodeContext.getNodePath());
+ JcrNodeTypeMetaDataImpl childNode = addChildNode(nameResolver, effectiveNodeTypeProvider, nodeTypeDefinitionProvider,
+ itemDefinitionProvider, false, nodeName, types.toArray(new Name[0]));
+ // now validate for validity
+ Optional<String> constraintViolation = childNode.validateAgainstParentNodeType(effectiveNodeType, nodeTypeDefinitionProvider,
+ itemDefinitionProvider);
+ if (constraintViolation.isPresent()) {
+ childNode.messages.add(new ValidationMessage(severity,
+ String.format(
+ isImplicit ? MESSAGE_CHILD_NODE_OF_NOT_CONTAINED_PARENT_POTENTIALLY_NOT_ALLOWED
+ : MESSAGE_CHILD_NODE_NOT_ALLOWED,
+ nodeName, primaryType,
+ getEffectiveNodeTypeLabel(nameResolver, effectiveNodeType),
+ constraintViolation.get()),
+ nodeContext));
+
+ }
+ return childNode;
+ }
+
+ private static List<Name> getTypes(NameResolver nameResolver, String primaryType, String... mixinTypes)
+ throws IllegalNameException, NamespaceException {
+ List<Name> types = new ArrayList<>();
+ types.add(getQName(nameResolver, primaryType, NameType.PRIMARY_TYPE));
+ if (mixinTypes != null) {
+ for (String mixinType : mixinTypes) {
+ types.add(getQName(nameResolver, mixinType, NameType.MIXIN_TYPE));
+ }
+ }
+ return types;
+ }
+
+ private @NotNull JcrNodeTypeMetaDataImpl addChildNode(@NotNull NameResolver nameResolver,
+ @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider,
+ @NotNull NodeTypeDefinitionProvider nodeTypeDefinitionProvider, @NotNull ItemDefinitionProvider itemDefinitionProvider,
+ boolean isImplicit, @NotNull String name, @Nullable Name... nodeTypes)
+ throws ConstraintViolationException, NoSuchNodeTypeException, NamespaceExceptionInNodeName, NamespaceException,
+ IllegalNameException {
+
+ final Name qName = getQName(nameResolver, name, NameType.NODE_NAME);
+
+ // special handling for users and acls
+ boolean isAuthenticationOrAuthorizationContext = false;
+ final EffectiveNodeType newEffectiveNodeType;
+ final Name newPrimaryNodeType;
+ if (nodeTypes != null) {
+ newEffectiveNodeType = effectiveNodeTypeProvider.getEffectiveNodeType(nodeTypes);
+ newPrimaryNodeType = nodeTypes[0];
+ isAuthenticationOrAuthorizationContext = isAclOrAuthorizableNodeType(newEffectiveNodeType);
+ } else {
+ newEffectiveNodeType = null;
+ newPrimaryNodeType = null;
+ }
+ // special handling for users and acls
+ if (!isAuthenticationOrAuthorizationContext) {
+ isAuthenticationOrAuthorizationContext = this.isAuthenticationOrAuthorizationContext;
+ }
+ JcrNodeTypeMetaDataImpl newNode = new JcrNodeTypeMetaDataImpl(qName, newPrimaryNodeType, newEffectiveNodeType, this,
+ isAuthenticationOrAuthorizationContext, isImplicit);
+ childNodesByName.put(qName, newNode);
+ return newNode;
+ }
+
+ /** Similar to
+ * {@link EffectiveNodeType#checkAddNodeConstraints(Name, org.apache.jackrabbit.spi.QNodeTypeDefinition, ItemDefinitionProvider)}
+ *
+ * @param parentEffectiveNodeType
+ * @return constraints violation message
+ * @throws RepositoryException */
+ private Optional<String> validateAgainstParentNodeType(@Nullable EffectiveNodeType parentEffectiveNodeType,
+ @NotNull NodeTypeDefinitionProvider nodeTypeDefinitionProvider,
+ @NotNull ItemDefinitionProvider itemDefinitionProvider) throws RepositoryException {
+ // except for ACL node types (for which the mixin rep:AccessControllable is transparently added) everything must comply with the
+ // parent node rules
+ if (effectiveNodeType.includesNodeType(NT_REP_POLICY)) {
+ return Optional.empty();
+ }
+
+ if (parentEffectiveNodeType == null) {
+ return Optional.empty();
+ }
+ QNodeTypeDefinition primaryNodeTypeDefinition = nodeTypeDefinitionProvider.getNodeTypeDefinition(primaryNodeType);
+ if (primaryNodeTypeDefinition.isAbstract()) {
+ return Optional.of(CONSTRAINT_ABSTRACT_TYPE_AS_PRIMARY_TYPE);
+ } else if (primaryNodeTypeDefinition.isMixin()) {
+ return Optional.of(CONSTRAINT_MIXIN_TYPE_AS_PRIMARY_TYPE);
+ }
+ try {
+ // get applicable node type from parent
+ QNodeDefinition applicableParentNodeDefinition = itemDefinitionProvider.getQNodeDefinition(parentEffectiveNodeType, this.name,
+ primaryNodeType);
+ if (!isAuthenticationOrAuthorizationContext && applicableParentNodeDefinition.isProtected()) {
+ return Optional.of(CONSTRAINT_CHILD_NODE_PROTECTED);
+ }
+ if (applicableParentNodeDefinition.isAutoCreated()) {
+ return Optional.of(CONSTRAINT_CHILD_NODE_AUTO_CREATED);
+ }
+ } catch (ConstraintViolationException e) {
+ return Optional.of(CONSTRAINT_CHILD_NODE_NOT_ALLOWED);
+ }
+ return Optional.empty();
+ }
+
+ @Override
+ public @NotNull Collection<ValidationMessage> finalizeValidation(@NotNull NamePathResolver namePathResolver,
+ @NotNull ValidationMessageSeverity severity, @NotNull WorkspaceFilter filter) throws NamespaceException {
+ if (!isValidationDone) {
+ Collection<ValidationMessage> messages = new LinkedList<>();
+ messages.add(new ValidationMessage(ValidationMessageSeverity.DEBUG,
+ "Validate mandatory children and properties of " + getQualifiedPath(namePathResolver)));
+ messages.addAll(validateMandatoryChildNodes(namePathResolver, severity, filter));
+ messages.addAll(validateMandatoryProperties(namePathResolver, severity));
+ // only remove child nodes on 2nd level to be able to validate mandatory properties of parent
+ childNodesByName.clear();
+ isValidationDone = true;
+ messages.add(new ValidationMessage(ValidationMessageSeverity.DEBUG,
+ "Remove node information of children of " + getQualifiedPath(namePathResolver)));
+ return messages;
+ } else {
+ return Collections.singletonList(new ValidationMessage(ValidationMessageSeverity.DEBUG,
+ "Already finalized validation of " + getQualifiedPath(namePathResolver)));
+ }
+ }
+
+ private Collection<ValidationMessage> validateMandatoryChildNodes(@NotNull NamePathResolver namePathResolver,
+ @NotNull ValidationMessageSeverity severity, @NotNull WorkspaceFilter filter) {
+ if (effectiveNodeType == null) {
+ return Collections.emptyList();
+ }
+
+ // validate mandatory child nodes of children
+ Collection<ValidationMessage> messages = new LinkedList<>();
+ for (QNodeDefinition mandatoryNodeType : effectiveNodeType.getMandatoryQNodeDefinitions()) {
+ // skip auto created ones
+ if (mandatoryNodeType.isAutoCreated()) {
+ continue;
+ }
+ boolean foundRequiredChildNode = false;
+ for (JcrNodeTypeMetaDataImpl child : childNodesByName.values()) {
+ foundRequiredChildNode = child.fulfillsNodeDefinition(mandatoryNodeType);
+ }
+
+ if (!foundRequiredChildNode && !mandatoryNodeType.getName().equals(NameConstants.ANY_NAME)) {
+ PathBuilder pathBuilder = new PathBuilder(this.getPath());
+ pathBuilder.addLast(mandatoryNodeType.getName());
+ try {
+ if (filter.contains(namePathResolver.getJCRPath(pathBuilder.getPath()))) {
+ messages.add(new ValidationMessage(severity, String.format(MESSAGE_MANDATORY_CHILD_NODE_MISSING,
+ getNodeDefinitionLabel(namePathResolver, mandatoryNodeType),
+ getEffectiveNodeTypeLabel(namePathResolver, effectiveNodeType), getQualifiedPath(namePathResolver))));
+ } else {
+ messages.add(new ValidationMessage(severity, String.format(MESSAGE_MANDATORY_UNCONTAINED_CHILD_NODE_MISSING,
+ getNodeDefinitionLabel(namePathResolver, mandatoryNodeType),
+ getEffectiveNodeTypeLabel(namePathResolver, effectiveNodeType), getQualifiedPath(namePathResolver))));
+ }
+ } catch (NamespaceException | MalformedPathException e) {
+ throw new IllegalStateException("Could not give out node types and name for " + mandatoryNodeType, e);
+ }
+ }
+ }
+
+ return messages;
+ }
+
+ private static String getEffectiveNodeTypeLabel(NameResolver nameResolver, EffectiveNodeType nodeType) throws NamespaceException {
+ return joinAsQualifiedJcrName(nameResolver, nodeType.getMergedNodeTypes());
+ }
+
+ private static String getNodeDefinitionLabel(NameResolver nameResolver, QNodeDefinition nodeDefinition) throws NamespaceException {
+ return nameResolver.getJCRName(nodeDefinition.getName()) + " ["
+ + joinAsQualifiedJcrName(nameResolver, nodeDefinition.getRequiredPrimaryTypes()) + "]";
+ }
+
+ private static String joinAsQualifiedJcrName(NameResolver nameResolver, Name[] names) throws NamespaceException {
+ StringBuilder types = new StringBuilder();
+ String delimiter = "";
+ for (Name name : names) {
+ types.append(delimiter).append(nameResolver.getJCRName(name));
+ delimiter = ", ";
+ }
+ return types.toString();
+ }
+
+ @Override
+ public @NotNull Collection<@NotNull ? extends JcrNodeTypeMetaData> getChildren() {
+ return childNodesByName.values();
+ }
+
+ @Override
+ public @NotNull JcrNodeTypeMetaData getOrCreateNode(NamePathResolver nameResolver, String path) throws RepositoryException {
+ return getNode(nameResolver, path, true).get();
+ }
+
+ @Override
+ public Optional<JcrNodeTypeMetaData> getNode(NamePathResolver nameResolver, String path) throws RepositoryException {
+ return getNode(nameResolver, path, false);
+ }
+
+ private Optional<JcrNodeTypeMetaData> getNode(NamePathResolver nameResolver, String path, boolean shouldCreateIfMissing)
+ throws RepositoryException {
+ // convert to fully namespaced path
+ Path qPath = nameResolver.getQPath(path);
+
+ // navigate there
+ Path qRelativePath = getPath().computeRelativePath(qPath);
+
+ // first go up until you reach a common parent
+ @NotNull
+ JcrNodeTypeMetaDataImpl currentNode = this;
+ for (Element element : qRelativePath.getElements()) {
+ if (!element.denotesParent()) {
+ break;
+ } else {
+ currentNode = currentNode.parentNode;
+ }
+ }
+ qRelativePath = currentNode.getPath().computeRelativePath(qPath);
+
+ // then go down until you match the path
+ for (Element element : qRelativePath.getElements()) {
+ if (element.denotesCurrent()) {
+ continue;
+ }
+ JcrNodeTypeMetaDataImpl childNode = currentNode.childNodesByName.get(element.getName());
+ if (childNode == null) {
+ if (shouldCreateIfMissing) {
+ childNode = currentNode.addUnknownChildNode(element.getName());
+ } else {
+ return Optional.empty();
+ }
+ }
+ currentNode = childNode;
+ }
+ return Optional.of(currentNode);
+ }
+
+ private Collection<ValidationMessage> validateMandatoryProperties(@NotNull NamePathResolver nameResolver,
+ @NotNull ValidationMessageSeverity severity) {
+
+ if (effectiveNodeType == null) {
+ return Collections.emptyList();
+ }
+ Collection<ValidationMessage> messages = new ArrayList<>();
+ // are all mandatory properties covered?
+ for (QPropertyDefinition mandatoryPropertyDefinition : effectiveNodeType.getMandatoryQPropertyDefinitions()) {
+ // ignore auto-created properties as they are created on-demand
+ if (mandatoryPropertyDefinition.isAutoCreated()) {
+ continue;
+ }
+ try {
+ if (!propertyTypesByName.containsKey(mandatoryPropertyDefinition.getName())) {
+ messages.add(new ValidationMessage(severity,
+ String.format(MESSAGE_MANDATORY_PROPERTY_MISSING,
+ nameResolver.getJCRName(mandatoryPropertyDefinition.getName()),
+ getEffectiveNodeTypeLabel(nameResolver, effectiveNodeType), getQualifiedPath(nameResolver))));
+ } else {
+ // check type
+ int actualPropertyType = propertyTypesByName.get(mandatoryPropertyDefinition.getName());
+ if (mandatoryPropertyDefinition.getRequiredType() != actualPropertyType) {
+ // check type
+ messages.add(new ValidationMessage(severity,
+ String.format(MESSAGE_MANDATORY_PROPERTY_WITH_WRONG_TYPE,
+ nameResolver.getJCRName(mandatoryPropertyDefinition.getName()),
+ PropertyType.nameFromValue(actualPropertyType),
+ PropertyType.nameFromValue(mandatoryPropertyDefinition.getRequiredType()),
+ getEffectiveNodeTypeLabel(nameResolver, effectiveNodeType), getQualifiedPath(nameResolver))));
+ }
+ }
+ } catch (NamespaceException e) {
+ throw new IllegalStateException("Could not give out parent node types or property names for " + mandatoryPropertyDefinition,
+ e);
+ }
+ }
+ return messages;
+ }
+
+ @Override
+ public void addProperty(@NotNull NodeContext nodeContext, @NotNull NamePathResolver namePathResolver,
+ @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider,
+ @NotNull NodeTypeDefinitionProvider nodeTypeDefinitionProvider, @NotNull ItemDefinitionProvider itemDefinitionProvider,
+ @NotNull ValidationMessageSeverity severity, String name, boolean isMultiValue, Value... values) throws RepositoryException {
+ // some sanity checks on multivalue
+ if (!isMultiValue && values.length > 1) {
+ throw new IllegalArgumentException("isMultiValue is only supposed to be false if exactly one value is passed but "
+ + values.length + " values were passed!");
+ }
+
+ Name qName;
+ try {
+ qName = namePathResolver.getQName(name);
+ } catch (IllegalNameException | NamespaceException e) {
+ throw new IllegalNameException("Invalid property name " + name, e);
+ }
+ propertyTypesByName.put(qName, values[0].getType());
+
+ // now check for validity
+ Optional<String> constraintViolation = validatePropertyConstraints(namePathResolver, effectiveNodeTypeProvider,
+ nodeTypeDefinitionProvider, itemDefinitionProvider, qName, values, isAuthenticationOrAuthorizationContext,
+ isMultiValue);
+ if (constraintViolation.isPresent()) {
+ messages.add(new ValidationMessage(severity,
+ String.format(
+ isImplicit ? MESSAGE_PROPERTY_OF_NOT_CONTAINED_PARENT_POTENTIALLY_NOT_ALLOWED
+ : MESSAGE_PROPERTY_NOT_ALLOWED,
+ namePathResolver.getJCRName(qName), PropertyType.nameFromValue(values[0].getType()),
+ getEffectiveNodeTypeLabel(namePathResolver, effectiveNodeType),
+ constraintViolation.get()),
+ nodeContext));
+ }
+ }
+
+ private @NotNull Optional<String> validatePropertyConstraints(@NotNull NamePathResolver namePathResolver,
+ @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider,
+ @NotNull NodeTypeDefinitionProvider nodeTypeDefinitionProvider, @NotNull ItemDefinitionProvider itemDefinitionProvider,
+ Name name, Value[] values, boolean allowProtected, boolean isMultiValue) throws RepositoryException {
+ if (effectiveNodeType == null) {
+ return Optional.empty();
+ }
+ QPropertyDefinition applicablePropertyDefinition;
+ try {
+ applicablePropertyDefinition = getPropertyDefinition(name, values[0].getType(), effectiveNodeType, itemDefinitionProvider,
+ isMultiValue);
+ } catch (ConstraintViolationException t) {
+ return Optional.of(CONSTRAINT_PROPERTY_NOT_ALLOWED);
+ }
+ if (applicablePropertyDefinition.isAutoCreated() && !ALLOWED_PROTECTED_PROPERTIES.contains(name)) {
+ return Optional.of(CONSTRAINT_PROPERTY_AUTO_CREATED);
+ }
+ if (applicablePropertyDefinition.isProtected() && !allowProtected && !ALLOWED_PROTECTED_PROPERTIES.contains(name)) {
+ return Optional.of(CONSTRAINT_PROPERTY_PROTECTED);
+ }
+
+ for (Value value : values) {
+ try {
+ QValue qValue = ValueFormat.getQValue(value, namePathResolver, QVALUE_FACTORY);
+ ValueConstraint.checkValueConstraints(applicablePropertyDefinition, new QValue[] { qValue });
+ } catch (ConstraintViolationException e) {
+ return Optional.of(String.format(CONSTRAINT_PROPERTY_VALUE, e.getLocalizedMessage()));
+ }
+ }
+ return Optional.empty();
+ }
+
+ private static QPropertyDefinition getPropertyDefinition(Name name, int type, EffectiveNodeType effectiveNodeType,
+ ItemDefinitionProvider itemDefinitionProvider, boolean isMultiValue)
+ throws NoSuchNodeTypeException, ConstraintViolationException {
+ QPropertyDefinition def;
+ try {
+ def = itemDefinitionProvider.getQPropertyDefinition(effectiveNodeType.getAllNodeTypes(), name, type,
+ isMultiValue);
+ } catch (ConstraintViolationException e) {
+ if (type != PropertyType.UNDEFINED) {
+ def = itemDefinitionProvider.getQPropertyDefinition(effectiveNodeType.getAllNodeTypes(), name, PropertyType.UNDEFINED,
+ isMultiValue);
+ } else {
+ throw e;
+ }
+ }
+ return def;
+ }
+
+ private boolean fulfillsNodeDefinition(QNodeDefinition nodeDefinition) {
+ // name must match
+ if (!nodeDefinition.getName().equals(NameConstants.ANY_NAME) && !nodeDefinition.getName().equals(name)) {
+ return false;
+ }
+
+ for (Name requiredType : nodeDefinition.getRequiredPrimaryTypes()) {
+ // type must match all of the given types
+ if (!effectiveNodeType.includesNodeType(requiredType)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public static @NotNull JcrNodeTypeMetaDataImpl createRoot(@NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider)
+ throws ConstraintViolationException, NoSuchNodeTypeException {
+ return new JcrNodeTypeMetaDataImpl(NameConstants.ROOT, NameConstants.REP_ROOT, effectiveNodeTypeProvider.getEffectiveNodeType(
+ new Name[] {
+ NameConstants.REP_ROOT,
+ NameConstants.REP_ACCESS_CONTROLLABLE,
+ NameConstants.REP_REPO_ACCESS_CONTROLLABLE }),
+ null, false, false);
+ }
+
+ @Override
+ public void fetchAndClearValidationMessages(Collection<ValidationMessage> messages) {
+ messages.addAll(this.messages);
+ this.messages.clear();
+ }
+
+ private Path getPath() {
+ if (parentNode == null) {
+ return PathFactoryImpl.getInstance().getRootPath();
+ } else {
+ PathBuilder pathBuilder = new PathBuilder(parentNode.getPath());
+ pathBuilder.addLast(name);
+ try {
+ return pathBuilder.getPath();
+ } catch (MalformedPathException e) {
+ throw new IllegalStateException("Could not create path from parent and name", e);
+ }
+ }
+ }
+
+ @Override
+ public String getQualifiedPath(NamePathResolver resolver) throws NamespaceException {
+ return resolver.getJCRPath(getPath());
+ }
+
+}
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/package-info.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NamespaceExceptionInNodeName.java
similarity index 62%
copy from vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/package-info.java
copy to vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NamespaceExceptionInNodeName.java
index 5a64445..410dd99 100644
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/package-info.java
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NamespaceExceptionInNodeName.java
@@ -14,11 +14,22 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+package org.apache.jackrabbit.vault.validation.spi.impl.nodetype;
-/**
- * The FileVault validation framework SPI. Provides classes/interfaces to implement validators on FileVault packages.
- */
-@Version("1.2.0")
-package org.apache.jackrabbit.vault.validation.spi;
+import javax.jcr.NamespaceException;
+
+public class NamespaceExceptionInNodeName extends NamespaceException {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ public NamespaceExceptionInNodeName(String message, Throwable rootCause) {
+ super(message, rootCause);
+ }
-import org.osgi.annotation.versioning.Version;
+ public NamespaceExceptionInNodeName(NamespaceException e) {
+ super(e.getLocalizedMessage(), e);
+ }
+}
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeNameAndType.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeNameAndType.java
deleted file mode 100644
index 0bec3a2..0000000
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeNameAndType.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.jackrabbit.vault.validation.spi.impl.nodetype;
-
-import java.util.Collection;
-import java.util.LinkedList;
-
-import javax.jcr.NamespaceException;
-import javax.jcr.nodetype.ConstraintViolationException;
-import javax.jcr.nodetype.NoSuchNodeTypeException;
-
-import org.apache.jackrabbit.jcr2spi.nodetype.EffectiveNodeType;
-import org.apache.jackrabbit.jcr2spi.nodetype.EffectiveNodeTypeProvider;
-import org.apache.jackrabbit.spi.Name;
-import org.apache.jackrabbit.spi.QNodeDefinition;
-import org.apache.jackrabbit.spi.commons.conversion.IllegalNameException;
-import org.apache.jackrabbit.spi.commons.conversion.NameResolver;
-import org.apache.jackrabbit.spi.commons.name.NameConstants;
-import org.apache.jackrabbit.vault.util.DocViewNode;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * Encapsulates the expanded name and its underlying effective node type.
- * In addition stores references to the child node names and types.
- */
-final class NodeNameAndType {
- private final Name name;
- private final EffectiveNodeType effectiveNodeType;
-
- public static NodeNameAndType createUnknownNodeNameAndType(@Nullable NodeNameAndType parent) {
- return new NodeNameAndType(parent);
- }
-
- private NodeNameAndType(@Nullable NodeNameAndType parent) {
- this.effectiveNodeType = null;
- this.name = null;
- }
-
- public NodeNameAndType(@NotNull NameResolver nameResolver, @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider, @NotNull DocViewNode node) throws IllegalNameException, NamespaceException, ConstraintViolationException, NoSuchNodeTypeException {
- this(nameResolver, effectiveNodeTypeProvider, node.name, node.primary, node.mixins);
- }
-
- public NodeNameAndType(@NotNull NameResolver nameResolver, @NotNull EffectiveNodeTypeProvider effectiveNodeTypeProvider, @NotNull String name, @NotNull String primaryType, String... mixinTypes) throws IllegalNameException, NamespaceException, ConstraintViolationException, NoSuchNodeTypeException {
- try {
- // special handling for root node (https://issues.apache.org/jira/browse/JCR-4625)
- if (name.isEmpty()) {
- this.name = NameConstants.ROOT;
- } else {
- this.name = nameResolver.getQName(name);
- }
- } catch (IllegalNameException|NamespaceException e) {
- throw new IllegalNameException("Invalid node name " + name + ": '" + e.getMessage() + "'", e);
- }
- Collection<Name> types = new LinkedList<>();
- try {
- types.add(nameResolver.getQName(primaryType));
- } catch (IllegalNameException|NamespaceException e) {
- throw new IllegalNameException("Invalid primary type " + primaryType + ": '" + e.getMessage() + "'", e);
- }
- if (mixinTypes != null) {
- for (String mixin : mixinTypes) {
- try {
- types.add(nameResolver.getQName(mixin));
- } catch (IllegalNameException|NamespaceException e) {
- throw new IllegalNameException("Invalid mixin type " + mixin + ": '" + e.getMessage() + "'", e);
- }
- }
- }
- effectiveNodeType = effectiveNodeTypeProvider.getEffectiveNodeType(types.toArray(new Name[0]));
- }
-
- public boolean isUnknown() {
- return this.effectiveNodeType == null && this.name == null;
- }
-
- public boolean fulfillsNodeDefinition(QNodeDefinition nodeDefinition) {
- // name must match
- if (!nodeDefinition.getName().equals(NameConstants.ANY_NAME) && !nodeDefinition.getName().equals(name)) {
- return false;
- }
-
- for (Name requiredType : nodeDefinition.getRequiredPrimaryTypes()) {
- // type must match one of the given types
- if (!effectiveNodeType.includesNodeType(requiredType)) {
- return false;
- }
- }
- return true;
- }
-
- public EffectiveNodeType getEffectiveNodeType() {
- return effectiveNodeType;
- }
-
- @Override
- public String toString() {
- return "NodeNameAndType [" + (name != null ? "name=" + name + ", " : "")
- + (effectiveNodeType != null ? "effectiveNodeType=" + effectiveNodeType : "") + "]";
- }
-
-
-}
\ No newline at end of file
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeManagerProvider.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeManagerProvider.java
index 1cc04af..05146d8 100644
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeManagerProvider.java
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeManagerProvider.java
@@ -60,22 +60,22 @@ import org.apache.jackrabbit.spi.commons.nodetype.NodeTypeStorage;
import org.apache.jackrabbit.spi.commons.nodetype.NodeTypeStorageImpl;
import org.apache.jackrabbit.spi.commons.value.QValueFactoryImpl;
import org.apache.jackrabbit.value.ValueFactoryImpl;
+import org.jetbrains.annotations.NotNull;
public class NodeTypeManagerProvider implements ManagerProvider, NamespaceStorage {
-
// namespace related helpers
- private final NamespaceMapping namespaceMapping;
- private final NamespaceRegistry namespaceRegistry;
- private final NamespaceResolver namespaceResolver;
- private final NamePathResolver npResolver;
+ private final @NotNull NamespaceMapping namespaceMapping;
+ private final @NotNull NamespaceRegistry namespaceRegistry;
+ private final @NotNull NamespaceResolver namespaceResolver;
+ private final @NotNull NamePathResolver npResolver;
// nodetype related helpers
- private final NodeTypeStorage nodeTypeStorage;
- private final NodeTypeRegistryImpl nodeTypeRegistry;
- private final NodeTypeManagerImpl nodeTypeManager;
+ private final @NotNull NodeTypeStorage nodeTypeStorage;
+ private final @NotNull NodeTypeRegistryImpl nodeTypeRegistry;
+ private final @NotNull NodeTypeManagerImpl nodeTypeManager;
- private final ItemDefinitionProvider itemDefinitionProvider;
+ private final @NotNull ItemDefinitionProvider itemDefinitionProvider;
public NodeTypeManagerProvider() throws IOException, RepositoryException, ParseException {
namespaceMapping = new NamespaceMapping();
@@ -88,7 +88,7 @@ public class NodeTypeManagerProvider implements ManagerProvider, NamespaceStorag
nodeTypeRegistry = NodeTypeRegistryImpl.create(nodeTypeStorage, namespaceRegistry);
nodeTypeManager = new NodeTypeManagerImpl(nodeTypeRegistry, this);
itemDefinitionProvider = new ItemDefinitionProviderImpl(nodeTypeRegistry, null, null);
- // always provide default
+ // always provide default nodetypes
try (Reader reader = new InputStreamReader(
this.getClass().getResourceAsStream("/default-nodetypes.cnd"),
StandardCharsets.US_ASCII)) {
@@ -101,26 +101,26 @@ public class NodeTypeManagerProvider implements ManagerProvider, NamespaceStorag
}
@Override
- public NamePathResolver getNamePathResolver() {
+ public @NotNull NamePathResolver getNamePathResolver() {
return npResolver;
}
@Override
- public NameResolver getNameResolver() {
+ public @NotNull NameResolver getNameResolver() {
return npResolver;
}
@Override
- public PathResolver getPathResolver() {
+ public @NotNull PathResolver getPathResolver() {
return npResolver;
}
@Override
- public NamespaceResolver getNamespaceResolver() {
+ public @NotNull NamespaceResolver getNamespaceResolver() {
return namespaceResolver;
}
- public NodeTypeManager getNodeTypeManager() {
+ public @NotNull NodeTypeManager getNodeTypeManager() {
return nodeTypeManager;
}
@@ -145,27 +145,27 @@ public class NodeTypeManagerProvider implements ManagerProvider, NamespaceStorag
}
@Override
- public ItemDefinitionProvider getItemDefinitionProvider() {
+ public @NotNull ItemDefinitionProvider getItemDefinitionProvider() {
return itemDefinitionProvider;
}
@Override
- public NodeTypeDefinitionProvider getNodeTypeDefinitionProvider() {
+ public @NotNull NodeTypeDefinitionProvider getNodeTypeDefinitionProvider() {
return nodeTypeManager;
}
@Override
- public EffectiveNodeTypeProvider getEffectiveNodeTypeProvider() {
+ public @NotNull EffectiveNodeTypeProvider getEffectiveNodeTypeProvider() {
return nodeTypeRegistry;
}
@Override
- public ValueFactory getJcrValueFactory() throws RepositoryException {
+ public @NotNull ValueFactory getJcrValueFactory() throws RepositoryException {
return ValueFactoryImpl.getInstance();
}
@Override
- public QValueFactory getQValueFactory() throws RepositoryException {
+ public @NotNull QValueFactory getQValueFactory() throws RepositoryException {
return QValueFactoryImpl.getInstance();
}
@@ -200,5 +200,4 @@ public class NodeTypeManagerProvider implements ManagerProvider, NamespaceStorag
throws NamespaceException, UnsupportedRepositoryOperationException, AccessDeniedException, RepositoryException {
namespaceMapping.removeMapping(uri);
}
-
}
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidator.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidator.java
index f3af76c..8d0d3de 100644
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidator.java
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidator.java
@@ -16,74 +16,61 @@
*/
package org.apache.jackrabbit.vault.validation.spi.impl.nodetype;
-import java.util.AbstractMap.SimpleEntry;
+import java.nio.file.Paths;
import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
-import java.util.Map;
+import java.util.Optional;
import java.util.Set;
-import java.util.TreeMap;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
import javax.jcr.NamespaceException;
-import javax.jcr.PropertyType;
+import javax.jcr.PathNotFoundException;
import javax.jcr.RepositoryException;
import javax.jcr.Value;
-import javax.jcr.ValueFactory;
import javax.jcr.ValueFormatException;
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.nodetype.NoSuchNodeTypeException;
-import javax.jcr.nodetype.NodeType;
import org.apache.commons.lang3.StringUtils;
-import org.apache.jackrabbit.jcr2spi.nodetype.EffectiveNodeType;
-import org.apache.jackrabbit.jcr2spi.nodetype.ItemDefinitionProvider;
-import org.apache.jackrabbit.jcr2spi.nodetype.NodeTypeDefinitionProvider;
+import org.apache.jackrabbit.JcrConstants;
+import org.apache.jackrabbit.oak.spi.nodetype.NodeTypeConstants;
import org.apache.jackrabbit.spi.Name;
-import org.apache.jackrabbit.spi.QNodeDefinition;
-import org.apache.jackrabbit.spi.QNodeTypeDefinition;
-import org.apache.jackrabbit.spi.QPropertyDefinition;
-import org.apache.jackrabbit.spi.QValue;
-import org.apache.jackrabbit.spi.QValueFactory;
import org.apache.jackrabbit.spi.commons.conversion.IllegalNameException;
-import org.apache.jackrabbit.spi.commons.conversion.NamePathResolver;
+import org.apache.jackrabbit.spi.commons.conversion.MalformedPathException;
+import org.apache.jackrabbit.spi.commons.conversion.NameParser;
import org.apache.jackrabbit.spi.commons.conversion.NameResolver;
import org.apache.jackrabbit.spi.commons.name.NameConstants;
import org.apache.jackrabbit.spi.commons.name.NameFactoryImpl;
-import org.apache.jackrabbit.spi.commons.nodetype.constraint.ValueConstraint;
-import org.apache.jackrabbit.spi.commons.value.ValueFormat;
-import org.apache.jackrabbit.value.ValueHelper;
+import org.apache.jackrabbit.value.BinaryValue;
+import org.apache.jackrabbit.value.DateValue;
+import org.apache.jackrabbit.value.StringValue;
import org.apache.jackrabbit.vault.fs.api.WorkspaceFilter;
-import org.apache.jackrabbit.vault.fs.spi.ACLManagement;
-import org.apache.jackrabbit.vault.fs.spi.UserManagement;
-import org.apache.jackrabbit.vault.fs.spi.impl.jcr20.JackrabbitUserManagement;
-import org.apache.jackrabbit.vault.fs.spi.impl.jcr20.JcrACLManagement;
import org.apache.jackrabbit.vault.util.DocViewNode;
import org.apache.jackrabbit.vault.util.DocViewProperty;
import org.apache.jackrabbit.vault.util.Text;
+import org.apache.jackrabbit.vault.validation.ValidationExecutor;
import org.apache.jackrabbit.vault.validation.spi.DocumentViewXmlValidator;
import org.apache.jackrabbit.vault.validation.spi.JcrPathValidator;
import org.apache.jackrabbit.vault.validation.spi.NodeContext;
import org.apache.jackrabbit.vault.validation.spi.ValidationMessage;
import org.apache.jackrabbit.vault.validation.spi.ValidationMessageSeverity;
+import org.apache.jackrabbit.vault.validation.spi.util.NodeContextImpl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class NodeTypeValidator implements DocumentViewXmlValidator, JcrPathValidator {
-
- static final String MESSAGE_MANDATORY_CHILD_NODE_MISSING = "Mandatory child node missing: %s";
- static final String MESSAGE_PROPERTY_ERROR = "Error while retrieving property '%s': %s";
- static final String MESSAGE_UNKNOWN_NODE_TYPE_OR_NAMESPACE = "%s. Skip validation of nodes with that type/name";
+ static final String MESSAGE_INVALID_PROPERTY_VALUE = "Property %s does not have a valid value: %s";
+ static final String MESSAGE_UNKNOWN_NODE_TYPE_OR_NAMESPACE = "%s Skip validation of nodes with that type/name";
static final String MESSAGE_MISSING_PRIMARY_TYPE = "Mandatory jcr:primaryType missing on node '%s'";
- static final String MESSAGE_PROPERTY_NOT_ALLOWED = "Property '%s' is not allowed in node with types '[%s]': %s";
- static final String MESSAGE_MANDATORY_PROPERTY_MISSING = "Mandatory property '%s' missing in node with types [%s]";
- static final String MESSAGE_CHILD_NODE_OF_NOT_CONTAINED_PARENT_POTENTIALLY_NOT_ALLOWED = "Node '%s' is not allowed as child of not contained node with potential default types '[%s]': %s";
- static final String MESSAGE_CHILD_NODE_NOT_ALLOWED = "Node '%s' is not allowed as child of node with types '[%s]': %s";
+
+ static final Value DUMMY_BINARY_VALUE = new BinaryValue("dummy binary");
+ static final Value DUMMY_DATE_VALUE = new DateValue(Calendar.getInstance());
+ static final Value DUMMY_STRING_VALUE = new StringValue("dummy string");
+
private final WorkspaceFilter filter;
private final ValidationMessageSeverity defaultSeverity;
private final ValidationMessageSeverity severityForUnknownNodeTypes;
@@ -91,35 +78,22 @@ public class NodeTypeValidator implements DocumentViewXmlValidator, JcrPathValid
private final NodeTypeManagerProvider ntManagerProvider;
private final Set<String> loggedUnknownNodeTypeMessages;
- private final EffectiveNodeType defaultType;
- private final UserManagement userManagement;
- private final ACLManagement aclManagement;
- private NodeContext protectedNodeContext;
- /** The context of the current node */
- private Map<String, NodeNameAndType> nodeTypePerPath;
-
- private static final Collection<Name> ALLOWED_PROTECTED_PROPERTIES = Arrays.asList(NameConstants.JCR_PRIMARYTYPE,
- NameConstants.JCR_MIXINTYPES);
-
- // properties being set by the {@link FileArtifactHandler} (they are part of another file) are ignored
- private static final Map<Name, List<Name>> IGNORED_MANDATORY_PROPERTIES_PER_NODE_TYPE = Stream.of(
- new SimpleEntry<>(NameConstants.NT_RESOURCE,
- Arrays.asList(NameConstants.JCR_DATA)))
- .collect(Collectors.toMap(SimpleEntry::getKey, SimpleEntry::getValue));
+ private final @NotNull Name defaultType;
+ private JcrNodeTypeMetaData currentNodeTypeMetaData;
public NodeTypeValidator(@NotNull WorkspaceFilter filter, @NotNull NodeTypeManagerProvider ntManagerProvider,
- @NotNull EffectiveNodeType defaultEffectiveNodeType, @NotNull ValidationMessageSeverity defaultSeverity,
- @NotNull ValidationMessageSeverity severityForUnknownNodeTypes) {
+ @NotNull Name defaultPrimaryNodeType, @NotNull ValidationMessageSeverity defaultSeverity,
+ @NotNull ValidationMessageSeverity severityForUnknownNodeTypes)
+ throws IllegalNameException, ConstraintViolationException, NoSuchNodeTypeException {
this.filter = filter;
this.ntManagerProvider = ntManagerProvider;
- this.defaultType = defaultEffectiveNodeType;
+ this.defaultType = defaultPrimaryNodeType;
this.defaultSeverity = defaultSeverity;
this.severityForUnknownNodeTypes = severityForUnknownNodeTypes;
this.docViewPropertyValueFactory = new DocViewPropertyValueFactory();
- this.userManagement = new JackrabbitUserManagement();
- this.aclManagement = new JcrACLManagement();
this.loggedUnknownNodeTypeMessages = new HashSet<>();
- this.nodeTypePerPath = new TreeMap<>();
+
+ this.currentNodeTypeMetaData = JcrNodeTypeMetaDataImpl.createRoot(ntManagerProvider.getEffectiveNodeTypeProvider());
}
static String getDocViewNodeLabel(DocViewNode node) {
@@ -147,327 +121,240 @@ public class NodeTypeValidator implements DocumentViewXmlValidator, JcrPathValid
return null;
}
}
-
- // special handling for users and acls
- if (aclManagement.isACLNodeType(node.primary) || userManagement.isAuthorizableNodeType(node.primary)) {
- protectedNodeContext = nodeContext;
- }
-
- boolean allowProtectedSubNodesAndProperties = protectedNodeContext != null;
Collection<ValidationMessage> messages = new LinkedList<>();
- String parentNodePath = Text.getRelativeParent(nodeContext.getNodePath(), 1);
- NodeNameAndType parentNodeNameAndType = nodeTypePerPath.get(parentNodePath);
- NodeNameAndType newNodeNameAndType = null;
- try {
- // check node itself against parent node type
- if (!aclManagement.isACLNodeType(node.primary)) {
- final EffectiveNodeType parentNodeType;
- final boolean useDefaultNodeType;
-
- if (parentNodeNameAndType == null || !filter.contains(parentNodePath)) {
- parentNodeType = defaultType;
- useDefaultNodeType = true;
- } else if (!parentNodeNameAndType.isUnknown()) {
- parentNodeType = parentNodeNameAndType.getEffectiveNodeType();
- useDefaultNodeType = false;
- } else {
- parentNodeType = null;
- useDefaultNodeType = false;
- }
+ messages.addAll(getOrCreateNewNode(nodeContext, isImplicit(nodeContext.getNodePath()), node.primary, node.mixins));
- if (parentNodeType != null) {
- String constraintViolation = getChildNodeConstraintViolation(node, parentNodeType,
- ntManagerProvider.getNodeTypeDefinitionProvider(),
- ntManagerProvider.getNameResolver(), ntManagerProvider.getItemDefinitionProvider(),
- allowProtectedSubNodesAndProperties);
- if (constraintViolation != null) {
- messages.add(new ValidationMessage(defaultSeverity,
- String.format(
- useDefaultNodeType ? MESSAGE_CHILD_NODE_OF_NOT_CONTAINED_PARENT_POTENTIALLY_NOT_ALLOWED
- : MESSAGE_CHILD_NODE_NOT_ALLOWED,
- getDocViewNodeLabel(node),
- effectiveNodeTypeToString(ntManagerProvider.getNameResolver(), parentNodeType),
- constraintViolation)));
-
- }
- }
+ for (DocViewProperty property : node.props.values()) {
+ try {
+ messages.addAll(addProperty(nodeContext, property.name, property.isMulti, docViewPropertyValueFactory.getValues(property)));
+ } catch (ValueFormatException e) {
+ messages.add(new ValidationMessage(defaultSeverity,
+ String.format(MESSAGE_INVALID_PROPERTY_VALUE, property.name, e.getLocalizedMessage())));
}
+ }
+ // emit messages
+ currentNodeTypeMetaData.fetchAndClearValidationMessages(messages);
- // get current node's node type and name and register in tree
- newNodeNameAndType = new NodeNameAndType(ntManagerProvider.getNameResolver(),
- ntManagerProvider.getEffectiveNodeTypeProvider(), node);
- nodeTypePerPath.put(nodeContext.getNodePath(), newNodeNameAndType);
-
- // check all properties
- Collection<Name> foundProperties = new ArrayList<>(node.props.size());
- for (DocViewProperty property : node.props.values()) {
- String constraintViolation = getPropertyConstraintViolation(property, newNodeNameAndType.getEffectiveNodeType(),
- allowProtectedSubNodesAndProperties);
- if (constraintViolation != null) {
- messages.add(new ValidationMessage(defaultSeverity, String.format(MESSAGE_PROPERTY_NOT_ALLOWED, property,
- effectiveNodeTypeToString(ntManagerProvider.getNameResolver(), newNodeNameAndType.getEffectiveNodeType()),
- constraintViolation)));
- }
- foundProperties.add(NameFactoryImpl.getInstance().create(property.name));
- }
- // are all mandatory properties covered?
- for (QPropertyDefinition mandatoryPropertyDefinition : newNodeNameAndType.getEffectiveNodeType()
- .getMandatoryQPropertyDefinitions()) {
- // ignore auto-created properties as they are created on-demand
- if (!mandatoryPropertyDefinition.isAutoCreated() && !foundProperties.contains(mandatoryPropertyDefinition.getName())) {
+ // defer checking for missing mandatory properties (as those might be added by some other files)
+ return messages;
+ }
- // ignore propertes which may be provided by the {@link FileArtifactHandler} (they are part of another file)
- List<Name> ignoredProperties = IGNORED_MANDATORY_PROPERTIES_PER_NODE_TYPE
- .get(mandatoryPropertyDefinition.getDeclaringNodeType());
- if (ignoredProperties != null && ignoredProperties.contains(mandatoryPropertyDefinition.getName())) {
- // TODO: skipping for now as validating those from other files requires major effort
- continue;
- }
- messages.add(new ValidationMessage(defaultSeverity,
- String.format(MESSAGE_MANDATORY_PROPERTY_MISSING, mandatoryPropertyDefinition.getName(),
- effectiveNodeTypeToString(ntManagerProvider.getNameResolver(),
- newNodeNameAndType.getEffectiveNodeType()))));
- }
- }
+ private boolean isImplicit(String path) {
+ return !filter.contains(path);
+ }
- } catch (NoSuchNodeTypeException | IllegalNameException | NamespaceException e) {
+ private Collection<ValidationMessage> addProperty(NodeContext nodeContext, String propertyName, boolean isMultiValue, Value... values) {
+ Collection<ValidationMessage> messages = new ArrayList<>();
+ try {
+ currentNodeTypeMetaData.addProperty(nodeContext, ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), defaultSeverity, propertyName, isMultiValue, values);
+ } catch (NoSuchNodeTypeException | NamespaceException e) {
// log each unknown node type/namespace only once!
if (!loggedUnknownNodeTypeMessages.contains(e.getMessage())) {
messages.add(new ValidationMessage(severityForUnknownNodeTypes,
- String.format(MESSAGE_UNKNOWN_NODE_TYPE_OR_NAMESPACE, e.getMessage()), e));
+ String.format(MESSAGE_UNKNOWN_NODE_TYPE_OR_NAMESPACE, e.getMessage()), nodeContext, e));
loggedUnknownNodeTypeMessages.add(e.getMessage());
}
- if (newNodeNameAndType == null) {
- nodeTypePerPath.put(nodeContext.getNodePath(), NodeNameAndType.createUnknownNodeNameAndType(parentNodeNameAndType));
- }
} catch (RepositoryException e) {
- throw new IllegalStateException("Could not validate nodes/properties against node types: " + e.getMessage(), e);
+ throw new IllegalStateException("Could not validate property against node types: " + e.getMessage(), e);
}
return messages;
}
- @Override
- public @Nullable Collection<ValidationMessage> validateEnd(@NotNull DocViewNode node, @NotNull NodeContext nodeContext,
- boolean isRoot) {
-
- if (nodeContext.equals(protectedNodeContext)) {
- protectedNodeContext = null;
- }
-
- // validate mandatory child nodes
- NodeNameAndType currentNodeNameAndType = nodeTypePerPath.get(nodeContext.getNodePath());
- if (currentNodeNameAndType != null && !currentNodeNameAndType.isUnknown()) {
- Collection<ValidationMessage> messages = new LinkedList<>();
- for (QNodeDefinition mandatoryNodeType : currentNodeNameAndType.getEffectiveNodeType().getMandatoryQNodeDefinitions()) {
- NodeNameAndType childNodeType;
- try {
- childNodeType = nodeTypePerPath.get(nodeContext.getNodePath() + "/" + ntManagerProvider.getNameResolver().getJCRName(mandatoryNodeType.getName()));
- } catch (NamespaceException e1) {
- throw new IllegalStateException("Could not find namespace for mandatory child node" + mandatoryNodeType.getName());
- }
- boolean foundRequiredChildNode = childNodeType != null && childNodeType.fulfillsNodeDefinition(mandatoryNodeType);
- if (!foundRequiredChildNode) {
- try {
- messages.add(new ValidationMessage(defaultSeverity, String.format(MESSAGE_MANDATORY_CHILD_NODE_MISSING,
- nodeDefinitionToString(ntManagerProvider.getNameResolver(), mandatoryNodeType))));
- } catch (NamespaceException e) {
- throw new IllegalStateException("Could not give out node types and name for " + mandatoryNodeType, e);
- }
- }
- }
- return messages;
- } else {
- return null;
+ private Optional<JcrNodeTypeMetaData> getNode(String nodePath) {
+ try {
+ return currentNodeTypeMetaData.getNode(ntManagerProvider.getNamePathResolver(), nodePath);
+ } catch (NamespaceException e) {
+ return Optional.empty();
+ } catch (RepositoryException e) {
+ throw new IllegalStateException("Could not get node types for path '" + nodePath + "': " + e.getMessage(), e);
}
-
}
- @Override
- public @Nullable Collection<ValidationMessage> validateJcrPath(@NotNull NodeContext nodeContext, boolean isFolder) {
- if (isFolder && !nodeTypePerPath.containsKey(nodeContext.getNodePath())) {
+ private @NotNull Collection<ValidationMessage> getOrCreateNewNode(NodeContext nodeContext, boolean isImplicit, String primaryType,
+ String... mixinTypes) {
+ Optional<JcrNodeTypeMetaData> node = getNode(nodeContext.getNodePath());
+ if (node.isPresent()) {
+ currentNodeTypeMetaData = node.get();
try {
- NodeNameAndType nodeNameAndType = new NodeNameAndType(ntManagerProvider.getNameResolver(),
- ntManagerProvider.getEffectiveNodeTypeProvider(), Text.getName(nodeContext.getNodePath()), NodeType.NT_FOLDER);
- nodeTypePerPath.put(nodeContext.getNodePath(), nodeNameAndType);
- } catch (NoSuchNodeTypeException | IllegalNameException | NamespaceException e) {
+ currentNodeTypeMetaData.setNodeTypes(ntManagerProvider.getNameResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ primaryType, mixinTypes);
+ } catch (NoSuchNodeTypeException | NamespaceException e) {
+ currentNodeTypeMetaData.setUnknownNodeTypes();
// log each unknown node type/namespace only once!
if (!loggedUnknownNodeTypeMessages.contains(e.getMessage())) {
loggedUnknownNodeTypeMessages.add(e.getMessage());
return Collections.singleton(new ValidationMessage(severityForUnknownNodeTypes,
- String.format(MESSAGE_UNKNOWN_NODE_TYPE_OR_NAMESPACE, e.getMessage()), e));
+ String.format(MESSAGE_UNKNOWN_NODE_TYPE_OR_NAMESPACE, e.getMessage(), nodeContext)));
}
} catch (RepositoryException e) {
- throw new IllegalStateException("Could not validate nodes/properties against node types: " + e.getMessage(), e);
+ throw new IllegalStateException(
+ "Could not create node type information for path '" + nodeContext.getNodePath() + "': " + e.getMessage(), e);
}
- }
- return null;
- }
-
- static String effectiveNodeTypeToString(NameResolver nameResolver, EffectiveNodeType nodeType) throws NamespaceException {
- return joinAsQualifiedJcrName(nameResolver, nodeType.getMergedNodeTypes());
- }
-
- static String nodeDefinitionToString(NameResolver nameResolver, QNodeDefinition nodeDefinition) throws NamespaceException {
- return nameResolver.getJCRName(nodeDefinition.getName()) + " ["
- + joinAsQualifiedJcrName(nameResolver, nodeDefinition.getRequiredPrimaryTypes()) + "]";
- }
-
- private static String joinAsQualifiedJcrName(NameResolver nameResolver, Name[] names) throws NamespaceException {
- StringBuilder types = new StringBuilder();
- String delimiter = "";
- for (Name name : names) {
- types.append(delimiter).append(nameResolver.getJCRName(name));
- delimiter = ", ";
- }
- return types.toString();
- }
-
- private static QPropertyDefinition getPropertyDefinition(Name name, int type, EffectiveNodeType effectiveNodeType,
- ItemDefinitionProvider itemDefinitionProvider, boolean multiValued)
- throws NoSuchNodeTypeException, ConstraintViolationException {
- QPropertyDefinition def;
- try {
- def = itemDefinitionProvider.getQPropertyDefinition(effectiveNodeType.getAllNodeTypes(), name, type,
- multiValued);
- } catch (ConstraintViolationException e) {
- if (type != PropertyType.UNDEFINED) {
- def = itemDefinitionProvider.getQPropertyDefinition(effectiveNodeType.getAllNodeTypes(), name, PropertyType.UNDEFINED,
- multiValued);
- } else {
- throw e;
- }
- }
- return def;
- }
-
- private static void validateValueConstraints(Value value, QPropertyDefinition def, ValueFactory valueFactory,
- QValueFactory qValueFactory, NamePathResolver namePathResolver) throws RepositoryException {
- final Value v;
- if (def.getRequiredType() != 0 && def.getRequiredType() != value.getType()) {
- v = ValueHelper.convert(value, def.getRequiredType(), valueFactory);
+ return Collections.emptyList();
} else {
- v = value;
+ return createNewNode(nodeContext, isImplicit, primaryType, mixinTypes);
}
- QValue qValue = ValueFormat.getQValue(v, namePathResolver, qValueFactory);
- ValueConstraint.checkValueConstraints(def, new QValue[] { qValue });
}
- String getPropertyConstraintViolation(DocViewProperty property, EffectiveNodeType effectiveNodeType, boolean allowProtected)
- throws RepositoryException {
- Name name = ntManagerProvider.getNameResolver().getQName(property.name);
-
+ private @NotNull Collection<ValidationMessage> createNewNode(NodeContext nodeContext, boolean isImplicit, String primaryType,
+ String... mixinTypes) {
+ Collection<ValidationMessage> messages = new ArrayList<>();
+ String nodePath = nodeContext.getNodePath();
+ if (nodePath.equals("/") && !isImplicit) {
+ throw new IllegalStateException("Can not create non implicit root node with path \"/\"");
+ }
+ String parentNodePath = Text.getRelativeParent(nodePath, 1);
+ String nodeName = Text.getName(nodePath);
try {
- if (property.isMulti) {
- return getPropertyConstraintViolation(name, docViewPropertyValueFactory.getValues(property), effectiveNodeType,
- ntManagerProvider.getItemDefinitionProvider(), ntManagerProvider.getJcrValueFactory(),
- ntManagerProvider.getQValueFactory(), ntManagerProvider.getNamePathResolver(), allowProtected);
- } else {
- return getPropertyConstraintViolation(name, docViewPropertyValueFactory.getValue(property), effectiveNodeType,
- ntManagerProvider.getItemDefinitionProvider(), ntManagerProvider.getJcrValueFactory(),
- ntManagerProvider.getQValueFactory(), ntManagerProvider.getNamePathResolver(), allowProtected);
+ //
+ JcrNodeTypeMetaData parentNode = currentNodeTypeMetaData.getOrCreateNode(ntManagerProvider.getNamePathResolver(),
+ parentNodePath);
+ try {
+ if (isImplicit) {
+ if (!nodePath.equals("/")) {
+ currentNodeTypeMetaData = parentNode.addImplicitChildNode(ntManagerProvider.getNameResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), nodeContext, defaultType);
+ } else {
+ // root node cannot be replaced
+ currentNodeTypeMetaData = parentNode;
+ }
+ } else {
+ currentNodeTypeMetaData = parentNode.addChildNode(ntManagerProvider.getNameResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), defaultSeverity, nodeContext, primaryType, mixinTypes);
+ }
+ } catch (NoSuchNodeTypeException | NamespaceException e) {
+ // TODO: NoSuchNodeTypeException might be thrown due to previous registration of the namespace for a node name
+
+ // log each unknown node type/namespace only once!
+ if (!loggedUnknownNodeTypeMessages.contains(e.getMessage())) {
+ messages.add(new ValidationMessage(severityForUnknownNodeTypes,
+ String.format(MESSAGE_UNKNOWN_NODE_TYPE_OR_NAMESPACE, e.getMessage()), nodeContext, e));
+ loggedUnknownNodeTypeMessages.add(e.getMessage());
+ }
+ if (e instanceof NamespaceExceptionInNodeName) {
+ // now register namespace with an arbitrary namespace url
+ NameParser.parse(nodeName, new OnDemandRegisterNamespaceResolverWrapper(ntManagerProvider),
+ NameFactoryImpl.getInstance());
+ messages.addAll(createNewNode(nodeContext, isImplicit, primaryType, mixinTypes));
+ } else {
+ currentNodeTypeMetaData = parentNode.addUnknownChildNode(ntManagerProvider.getNameResolver(), nodeName);
+ }
}
- } catch (NamespaceException e) {
- throw new NamespaceException(String.format(MESSAGE_PROPERTY_ERROR, property.name, e.getMessage()), e);
} catch (RepositoryException e) {
- throw new RepositoryException(String.format(MESSAGE_PROPERTY_ERROR, property.name, e.getMessage()), e);
- }
- }
-
- static String getPropertyConstraintViolation(Name name, Value value, EffectiveNodeType effectiveNodeType,
- ItemDefinitionProvider itemDefinitionProvider, ValueFactory valueFactory, QValueFactory qValueFactory,
- NamePathResolver namePathResolver, boolean allowProtected) throws RepositoryException {
- QPropertyDefinition def;
- try {
- def = getPropertyDefinition(name, value.getType(), effectiveNodeType, itemDefinitionProvider, false);
- } catch (ConstraintViolationException t) {
- return "No property definition found for name!";
- }
-
- if (def.isProtected() && !allowProtected && !ALLOWED_PROTECTED_PROPERTIES.contains(name)) {
- return "Property is protected!";
+ throw new IllegalStateException("Could not create node type information for path '" + nodePath + "': " + e.getMessage(), e);
}
-
- // single values are valid for multi and single value
- try {
- validateValueConstraints(value, def, valueFactory, qValueFactory, namePathResolver);
- } catch (ConstraintViolationException e) {
- return "Property value does not satisfy constraints: " + e.getLocalizedMessage();
- } catch (ValueFormatException e) {
- return "Cannot convert property into type '" + def.getRequiredType() + "': " + e.getLocalizedMessage();
- }
- return null;
+ return messages;
}
- static String getPropertyConstraintViolation(Name name, Value[] values, EffectiveNodeType effectiveNodeType,
- ItemDefinitionProvider itemDefinitionProvider, ValueFactory valueFactory, QValueFactory qValueFactory,
- NamePathResolver namePathResolver, boolean allowProtected) throws RepositoryException {
- QPropertyDefinition def;
- int type = values.length > 0 ? values[0].getType() : PropertyType.UNDEFINED;
- try {
- def = getPropertyDefinition(name, type, effectiveNodeType, itemDefinitionProvider, true);
- } catch (ConstraintViolationException t) {
- return "No property definition found for name!";
- }
- if (def.isProtected() && !allowProtected && !ALLOWED_PROTECTED_PROPERTIES.contains(name)) {
- return "Property is protected!";
- }
- if (!def.isMultiple()) {
- return "Property must be single-value!";
+ /** Called whenever some subtree was fully visited
+ *
+ * @param nodePath
+ * @return
+ * @throws RepositoryException
+ * @throws PathNotFoundException
+ * @throws IllegalArgumentException
+ * @throws NamespaceException
+ * @throws IllegalNameException
+ * @throws MalformedPathException */
+ private @Nullable Collection<ValidationMessage> finalizeValidationForSiblings(NodeContext nodeContext) {
+ String parentNodePath = Text.getRelativeParent(nodeContext.getNodePath(), 1);
+ String nodeName = Text.getName(nodeContext.getNodePath());
+ Collection<ValidationMessage> messages = new ArrayList<>();
+ Optional<JcrNodeTypeMetaData> parentNode = getNode(parentNodePath);
+ if (!parentNode.isPresent()) {
+ throw new IllegalArgumentException("Could not find parent node definition at " + parentNodePath);
}
- for (Value value : values) {
+ String path = parentNodePath + "/" + nodeName;
+ for (JcrNodeTypeMetaData sibling : parentNode.get().getChildren()) {
try {
- validateValueConstraints(value, def, valueFactory, qValueFactory, namePathResolver);
- } catch (ConstraintViolationException e) {
- return "Property value does not satisfy constraints: " + e.getLocalizedMessage();
- } catch (ValueFormatException e) {
- return "Cannot convert property into type '" + def.getRequiredType() + "': " + e.getLocalizedMessage();
+ if (sibling.getQualifiedPath(ntManagerProvider.getNamePathResolver()).equals(path)) {
+ continue;
+ }
+ for (JcrNodeTypeMetaData siblingChild : sibling.getChildren()) {
+ messages.addAll(finalizeValidationForSubtree(siblingChild, nodeContext));
+ }
+ } catch (NamespaceException e) {
+ throw new IllegalStateException("Can not print qualified path for " + path, e);
}
}
- return null;
+ return messages;
}
- static String getChildNodeConstraintViolation(DocViewNode node, EffectiveNodeType nodeType,
- NodeTypeDefinitionProvider nodeTypeDefinitionProvider,
- NameResolver nameResolver, ItemDefinitionProvider itemDefinitionProvider, boolean allowProtected)
- throws RepositoryException {
- final Name nodeName;
- try {
- nodeName = nameResolver.getQName(node.name);
- } catch (IllegalNameException | NamespaceException e) {
- throw new IllegalNameException("Invalid node name " + node.name + ": '" + e.getMessage() + "'", e);
- }
- QNodeTypeDefinition nodeTypeDefinition;
- try {
- nodeTypeDefinition = nodeTypeDefinitionProvider.getNodeTypeDefinition(nameResolver.getQName(node.primary));
- } catch (IllegalNameException | NamespaceException e) {
- throw new IllegalNameException("Invalid primary type " + node.primary + ": '" + e.getMessage() + "'", e);
- }
- if (nodeTypeDefinition.isAbstract()) {
- return "Not allowed to add node with abstract node type as primary type";
+ private @Nullable Collection<ValidationMessage> finalizeValidationForSubtree(JcrNodeTypeMetaData node, NodeContext nodeContext) throws NamespaceException {
+ Collection<ValidationMessage> messages = new ArrayList<>();
+ for (JcrNodeTypeMetaData child : node.getChildren()) {
+ messages.addAll(finalizeValidationForSubtree(child, nodeContext));
+ messages.addAll(child.finalizeValidation(ntManagerProvider.getNamePathResolver(), defaultSeverity, filter));
}
- if (nodeTypeDefinition.isMixin()) {
- return "Not allowed to add node with a mixin as primary node type";
- }
- try {
- QNodeDefinition nd = itemDefinitionProvider.getQNodeDefinition(nodeType, nodeName, nodeTypeDefinition.getName());
+ return messages;
+ }
- if (!allowProtected && nd.isProtected()) {
- return "Node is protected and can not be manually added";
+ @Override
+ public @Nullable Collection<ValidationMessage> validateJcrPath(@NotNull NodeContext nodeContext, boolean isFolder,
+ boolean isDocViewXml) {
+ // track folders
+ List<ValidationMessage> messages = new ArrayList<>();
+ boolean isImplicit = isImplicit(nodeContext.getNodePath());
+ if (isFolder) {
+ messages.addAll(getOrCreateNewNode(nodeContext, isImplicit, NodeTypeConstants.NT_FOLDER));
+ //
+ if (!nodeContext.getNodePath().equals("/")) {
+ messages.addAll(finalizeValidationForSiblings(nodeContext));
}
-
- if (nd.isAutoCreated()) {
- return "Node is auto-created and can not be manually added";
+ } else {
+ // for all files which are not docview
+ if (!isDocViewXml) {
+ String fileName = nodeContext.getFilePath().getFileName().toString();
+ // https://jackrabbit.apache.org/filevault/vaultfs.html#Binary_Properties
+ if (fileName.endsWith(ValidationExecutor.EXTENSION_BINARY)) {
+ // create parent if it does not exist yet
+ messages.addAll(getOrCreateNewNode(nodeContext, isImplicit, NodeTypeConstants.NT_FOLDER));
+ String propertyName = fileName.substring(0, fileName.length() - ValidationExecutor.EXTENSION_BINARY.length());
+ messages.addAll(addProperty(nodeContext, propertyName, false, DUMMY_BINARY_VALUE));
+ } else {
+ // if binary node is not yet there
+ messages.addAll(getOrCreateNewNode(nodeContext, isImplicit, NodeTypeConstants.NT_FILE));
+ // if a NT_FILE create a jcr:content sub node of type NT_RESOURCE
+ if (currentNodeTypeMetaData.getPrimaryNodeType().equals(NameConstants.NT_FILE)) {
+ // create new node context
+ nodeContext = new NodeContextImpl(nodeContext.getNodePath() + "/" + JcrConstants.JCR_CONTENT,
+ nodeContext.getFilePath(), nodeContext.getBasePath());
+ messages.addAll(
+ getOrCreateNewNode(nodeContext, isImplicit(nodeContext.getNodePath()), NodeTypeConstants.NT_RESOURCE));
+ }
+ messages.addAll(addProperty(nodeContext, JcrConstants.JCR_DATA, false, DUMMY_BINARY_VALUE));
+ messages.addAll(addProperty(nodeContext, JcrConstants.JCR_MIMETYPE, false, DUMMY_STRING_VALUE));
+ messages.addAll(addProperty(nodeContext, JcrConstants.JCR_LASTMODIFIED, false, DUMMY_DATE_VALUE));
+ }
}
- } catch (ConstraintViolationException e) {
- return "Could not find matching child node definition in parent's node type";
}
- return null;
+ return messages;
+ }
+
+ static String joinAsQualifiedJcrName(NameResolver nameResolver, Name[] names) throws NamespaceException {
+ StringBuilder types = new StringBuilder();
+ String delimiter = "";
+ for (Name name : names) {
+ types.append(delimiter).append(nameResolver.getJCRName(name));
+ delimiter = ", ";
+ }
+ return types.toString();
}
@Override
public @Nullable Collection<ValidationMessage> done() {
- return null;
+ // validate any outstanding nodes
+ // TODO: use correct node context impl
+ try {
+ return finalizeValidationForSubtree(getNode("/").get(), new NodeContextImpl("/", Paths.get("/"), Paths.get("/")));
+ } catch (NamespaceException e) {
+ throw new IllegalStateException("Can not print qualified path", e);
+ }
}
}
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidatorFactory.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidatorFactory.java
index f3a7f0e..7b3c875 100644
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidatorFactory.java
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidatorFactory.java
@@ -31,7 +31,6 @@ import javax.jcr.RepositoryException;
import org.apache.commons.lang3.StringUtils;
import org.apache.jackrabbit.JcrConstants;
import org.apache.jackrabbit.commons.cnd.ParseException;
-import org.apache.jackrabbit.jcr2spi.nodetype.EffectiveNodeType;
import org.apache.jackrabbit.vault.validation.spi.ValidationContext;
import org.apache.jackrabbit.vault.validation.spi.ValidationMessageSeverity;
import org.apache.jackrabbit.vault.validation.spi.Validator;
@@ -65,7 +64,7 @@ public class NodeTypeValidatorFactory implements ValidatorFactory {
// either load map from classloader, from filesystem or from generic url
if (StringUtils.isBlank(cndUrls)) {
cndUrls = this.getClass().getClassLoader().getResource("default-nodetypes.cnd").toString();
- LOGGER.warn("Using default nodetypes, consider specifying the nodetypes from the distribution you use!");
+ LOGGER.warn("Using default nodetypes, consider specifying the nodetypes from the repository you use!");
}
final String defaultNodeType;
@@ -94,9 +93,7 @@ public class NodeTypeValidatorFactory implements ValidatorFactory {
throw new IllegalArgumentException("Error loading node types from CND at " + cndUrl, e);
}
}
- EffectiveNodeType defaultEffectiveNodeType = ntManagerProvider.getEffectiveNodeTypeProvider()
- .getEffectiveNodeType(ntManagerProvider.getNameResolver().getQName(defaultNodeType));
- return new NodeTypeValidator(context.getFilter(), ntManagerProvider, defaultEffectiveNodeType, settings.getDefaultSeverity(),
+ return new NodeTypeValidator(context.getFilter(), ntManagerProvider, ntManagerProvider.getNameResolver().getQName(defaultNodeType), settings.getDefaultSeverity(),
severityForUnknownNodetypes);
} catch (IOException | RepositoryException | ParseException e) {
throw new IllegalArgumentException("Error loading default node type " + defaultNodeType, e);
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/OnDemandRegisterNamespaceResolverWrapper.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/OnDemandRegisterNamespaceResolverWrapper.java
new file mode 100644
index 0000000..03464c6
--- /dev/null
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/OnDemandRegisterNamespaceResolverWrapper.java
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.jackrabbit.vault.validation.spi.impl.nodetype;
+
+import javax.jcr.NamespaceException;
+import javax.jcr.RepositoryException;
+
+import org.apache.jackrabbit.jcr2spi.NamespaceStorage;
+import org.apache.jackrabbit.spi.commons.namespace.NamespaceResolver;
+
+
+public class OnDemandRegisterNamespaceResolverWrapper implements NamespaceResolver {
+
+ private final NamespaceStorage nsStorage;
+ static final String UNDECLARED_NAMESPACE_URI_PREFIX = "http://unknown.prefix.";
+
+
+ public OnDemandRegisterNamespaceResolverWrapper(NamespaceStorage nsStorage) {
+ super();
+ this.nsStorage = nsStorage;
+ }
+
+ @Override
+ public String getPrefix(String uri) throws NamespaceException {
+ try {
+ return nsStorage.getPrefix(uri);
+ } catch (RepositoryException e) {
+ throw new NamespaceException(e);
+ }
+ }
+
+ @Override
+ public String getURI(String prefix) throws NamespaceException {
+ try {
+ try {
+ return nsStorage.getURI(prefix);
+ } catch (NamespaceException e) {
+ String newNamespaceUri = UNDECLARED_NAMESPACE_URI_PREFIX + prefix;
+ nsStorage.registerNamespace(prefix, newNamespaceUri);
+ return newNamespaceUri;
+ }
+ } catch (RepositoryException e) {
+ throw new NamespaceException("Could not register prefix " + prefix + " on demand", e);
+ }
+ }
+
+}
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/package-info.java b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/package-info.java
index 5a64445..0dfdeae 100644
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/package-info.java
+++ b/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/package-info.java
@@ -18,7 +18,7 @@
/**
* The FileVault validation framework SPI. Provides classes/interfaces to implement validators on FileVault packages.
*/
-@Version("1.2.0")
+@Version("1.3.0")
package org.apache.jackrabbit.vault.validation.spi;
import org.osgi.annotation.versioning.Version;
diff --git a/vault-validation/src/test/java/org/apache/jackrabbit/vault/validation/ValidationExecutorTest.java b/vault-validation/src/test/java/org/apache/jackrabbit/vault/validation/ValidationExecutorTest.java
index 4477a3f..5194220 100644
--- a/vault-validation/src/test/java/org/apache/jackrabbit/vault/validation/ValidationExecutorTest.java
+++ b/vault-validation/src/test/java/org/apache/jackrabbit/vault/validation/ValidationExecutorTest.java
@@ -170,7 +170,7 @@ public class ValidationExecutorTest {
CapturingInputStreamFromArgumentAnswer<Void> answer2 = new CapturingInputStreamFromArgumentAnswer<>(StandardCharsets.US_ASCII, 0, null);
Mockito.when(genericJcrDataValidator2.shouldValidateJcrData(Mockito.any(), Mockito.any())).thenReturn(true);
Mockito.when(genericJcrDataValidator2.validateJcrData(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenAnswer(answer2);
- Mockito.when(jcrPathValidator.validateJcrPath(Mockito.any(), Mockito.anyBoolean())).thenReturn(Collections.singleton(new ValidationMessage(ValidationMessageSeverity.ERROR, "patherror")));
+ Mockito.when(jcrPathValidator.validateJcrPath(Mockito.any(), Mockito.anyBoolean(), Mockito.anyBoolean())).thenReturn(Collections.singleton(new ValidationMessage(ValidationMessageSeverity.ERROR, "patherror")));
try (InputStream input = this.getClass().getResourceAsStream("/simple-package/jcr_root/apps/genericfile.xml")) {
Collection<ValidationViolation> messages = validate(input, executor, Paths.get(""), "apps/genericfile.xml", false);
assertViolation(messages,
@@ -180,7 +180,7 @@ public class ValidationExecutorTest {
Assert.assertEquals("Test", answer2.getValue());
Path expectedPath = Paths.get("apps/genericfile.xml");
NodeContext expectedNodeContext = new NodeContextImpl("/apps/genericfile.xml", expectedPath, Paths.get(""));
- Mockito.verify(jcrPathValidator).validateJcrPath(expectedNodeContext, false);
+ Mockito.verify(jcrPathValidator).validateJcrPath(expectedNodeContext, false, false);
Mockito.verify(genericJcrDataValidator, Mockito.atLeastOnce()).shouldValidateJcrData(expectedPath, Paths.get(""));
Mockito.verify(genericJcrDataValidator).validateJcrData(Mockito.any(), Mockito.eq(expectedPath), Mockito.eq(Paths.get("")), Mockito.any());
Mockito.verify(genericJcrDataValidator2, Mockito.atLeastOnce()).shouldValidateJcrData(expectedPath, Paths.get(""));
@@ -203,7 +203,7 @@ public class ValidationExecutorTest {
Collection<ValidationViolation> messages = validateFolder(executor, Paths.get(""), "apps.dir", false);
Assert.assertThat(messages, AnyValidationViolationMatcher.noValidationInCollection());
NodeContext expectedNodeContext = new NodeContextImpl("/apps", Paths.get("apps.dir"), Paths.get(""));
- Mockito.verify(jcrPathValidator).validateJcrPath(expectedNodeContext, true);
+ Mockito.verify(jcrPathValidator).validateJcrPath(expectedNodeContext, true, true);
Mockito.verify(nodePathValidator).validate(expectedNodeContext);
}
@@ -244,6 +244,8 @@ public class ValidationExecutorTest {
public void testFilePathToNodePath() {
Assert.assertEquals("/apps/test", ValidationExecutor.filePathToNodePath(Paths.get("apps", "test")));
Assert.assertEquals("/some/other/path", ValidationExecutor.filePathToNodePath(Paths.get("some", "other", "path")));
+ Assert.assertEquals("/apps/test", ValidationExecutor.filePathToNodePath(Paths.get("apps", "test", "property.binary")));
+ Assert.assertEquals("/", ValidationExecutor.filePathToNodePath(Paths.get("")));
}
public static void assertViolation(Collection<? extends ValidationMessage> messages, ValidationMessageSeverity thresholdSeverity, ValidationMessage... violations) {
diff --git a/vault-validation/src/test/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/JcrNodeTypeMetaDataImplTest.java b/vault-validation/src/test/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/JcrNodeTypeMetaDataImplTest.java
new file mode 100644
index 0000000..eb9c143
--- /dev/null
+++ b/vault-validation/src/test/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/JcrNodeTypeMetaDataImplTest.java
@@ -0,0 +1,411 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.jackrabbit.vault.validation.spi.impl.nodetype;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collection;
+
+import javax.jcr.NamespaceException;
+import javax.jcr.PathNotFoundException;
+import javax.jcr.RepositoryException;
+import javax.jcr.UnsupportedRepositoryOperationException;
+import javax.jcr.nodetype.InvalidNodeTypeDefinitionException;
+import javax.jcr.nodetype.NoSuchNodeTypeException;
+import javax.jcr.nodetype.NodeType;
+import javax.jcr.nodetype.NodeTypeExistsException;
+
+import org.apache.jackrabbit.commons.cnd.ParseException;
+import org.apache.jackrabbit.oak.spi.nodetype.NodeTypeConstants;
+import org.apache.jackrabbit.spi.commons.conversion.IllegalNameException;
+import org.apache.jackrabbit.spi.commons.conversion.MalformedPathException;
+import org.apache.jackrabbit.value.ValueFactoryImpl;
+import org.apache.jackrabbit.vault.fs.api.PathFilterSet;
+import org.apache.jackrabbit.vault.fs.config.DefaultWorkspaceFilter;
+import org.apache.jackrabbit.vault.validation.AnyValidationMessageMatcher;
+import org.apache.jackrabbit.vault.validation.ValidationExecutorTest;
+import org.apache.jackrabbit.vault.validation.spi.NodeContext;
+import org.apache.jackrabbit.vault.validation.spi.ValidationMessage;
+import org.apache.jackrabbit.vault.validation.spi.ValidationMessageSeverity;
+import org.apache.jackrabbit.vault.validation.spi.util.NodeContextImpl;
+import org.hamcrest.Matchers;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JcrNodeTypeMetaDataImplTest {
+
+ private NodeTypeManagerProvider ntManagerProvider;
+
+ private JcrNodeTypeMetaDataImpl root;
+
+ private static final String ROOT_NODE_TYPES = "rep:AccessControllable, rep:RepoAccessControllable, rep:root"; // alphabetical order
+ // (i.e. primary type // last)
+
+ @Before
+ public void setUp() throws IOException, RepositoryException, ParseException {
+ ntManagerProvider = new NodeTypeManagerProvider();
+ root = JcrNodeTypeMetaDataImpl.createRoot(ntManagerProvider.getEffectiveNodeTypeProvider());
+ }
+
+ static NodeContext createSimpleNodeContext(String nodePath) {
+ return new NodeContextImpl(nodePath, Paths.get(""), Paths.get(""));
+ }
+
+ @Test
+ public void testGetNode() throws RepositoryException {
+ ValidationMessageSeverity severity = ValidationMessageSeverity.ERROR;
+ JcrNodeTypeMetaData child = root.addChildNode(ntManagerProvider.getNameResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(), severity,
+ createSimpleNodeContext("my"),
+ NodeType.NT_FOLDER);
+ assertNoValidationErrors(child);
+ JcrNodeTypeMetaData grandChild = child.addChildNode(ntManagerProvider.getNameResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(), severity,
+ createSimpleNodeContext("test"),
+ NodeType.NT_FOLDER);
+ assertNoValidationErrors(grandChild);
+ JcrNodeTypeMetaData child2 = root.addChildNode(ntManagerProvider.getNameResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(), severity,
+ createSimpleNodeContext("test2"),
+ NodeType.NT_FOLDER);
+ assertNoValidationErrors(child2);
+ Assert.assertEquals(child2,
+ grandChild.getNode(ntManagerProvider.getNamePathResolver(), "/test2").get());
+ }
+
+ public void testGetNodeWithNonExistingPath() throws MalformedPathException, NamespaceException, IllegalArgumentException,
+ PathNotFoundException, RepositoryException {
+
+ ValidationMessageSeverity severity = ValidationMessageSeverity.ERROR;
+ JcrNodeTypeMetaData child = root.addChildNode(ntManagerProvider.getNameResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(), severity,
+ createSimpleNodeContext("my"),
+ NodeType.NT_FOLDER);
+ JcrNodeTypeMetaData grandChild = child.addChildNode(ntManagerProvider.getNameResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), severity, createSimpleNodeContext("test"), NodeType.NT_FOLDER);
+ Assert.assertFalse(grandChild.getNode(ntManagerProvider.getNamePathResolver(), "/test2").isPresent());
+ }
+
+ @Test(expected = NamespaceExceptionInNodeName.class)
+ public void testAddChildNodeWithUndeclaredNamespaceInName() throws RepositoryException {
+ root.addChildNode(ntManagerProvider.getNamePathResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ createSimpleNodeContext("invalid:name"), NodeTypeConstants.NT_FOLDER);
+ }
+
+ @Test(expected = NamespaceException.class)
+ public void testAddChildNodeWithUndeclaredNamespaceInType() throws RepositoryException {
+ root.addChildNode(ntManagerProvider.getNamePathResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ createSimpleNodeContext("myname"), "my:nodeType1");
+ }
+
+ @Test(expected = NoSuchNodeTypeException.class)
+ public void testAddChildNodeWithUndeclaredType() throws RepositoryException {
+ root.addChildNode(ntManagerProvider.getNamePathResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ createSimpleNodeContext("myname"), "jcr:nodeType1");
+ }
+
+ @Test
+ public void testAddChildNode() throws IOException, InvalidNodeTypeDefinitionException, NodeTypeExistsException,
+ UnsupportedRepositoryOperationException, ParseException, RepositoryException {
+ try (InputStream input = this.getClass().getResourceAsStream("/simple-restricted-nodetypes.cnd");
+ Reader reader = new InputStreamReader(input,
+ StandardCharsets.US_ASCII)) {
+ ntManagerProvider.registerNodeTypes(reader);
+ }
+
+ // add child node with mixin type as primary
+ NodeContext nodeContext = createSimpleNodeContext("name");
+ JcrNodeTypeMetaData node = root.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, nodeContext,
+ "mix:mimeType");
+ assertValidationMessage(node, new ValidationMessage(ValidationMessageSeverity.ERROR,
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_CHILD_NODE_NOT_ALLOWED, "name", "mix:mimeType", ROOT_NODE_TYPES,
+ JcrNodeTypeMetaDataImpl.CONSTRAINT_MIXIN_TYPE_AS_PRIMARY_TYPE),
+ nodeContext));
+
+ // add child node with abstract type
+ node = root.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, nodeContext,
+ "nt:hierarchyNode");
+ assertValidationMessage(node, new ValidationMessage(ValidationMessageSeverity.ERROR,
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_CHILD_NODE_NOT_ALLOWED, "name", "nt:hierarchyNode", ROOT_NODE_TYPES,
+ JcrNodeTypeMetaDataImpl.CONSTRAINT_ABSTRACT_TYPE_AS_PRIMARY_TYPE),
+ nodeContext));
+
+ node = root.addChildNode(ntManagerProvider.getNamePathResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ createSimpleNodeContext("versionedNode"), "rep:versionStorage");
+ assertNoValidationErrors(node);
+
+ // add child node with protected node which is ACL (i.e. accepted)
+ JcrNodeTypeMetaData childNode = node.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ createSimpleNodeContext("rep:policy"), "rep:Policy");
+ assertNoValidationErrors(childNode);
+
+ // add child node with protected node which is not ACL (i.e. accepted)
+ childNode = node.addChildNode(ntManagerProvider.getNamePathResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ nodeContext, "nt:versionHistory");
+ assertValidationMessage(childNode, new ValidationMessage(ValidationMessageSeverity.ERROR,
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_CHILD_NODE_NOT_ALLOWED, "name", "nt:versionHistory", "rep:versionStorage",
+ JcrNodeTypeMetaDataImpl.CONSTRAINT_CHILD_NODE_PROTECTED),
+ nodeContext));
+
+ // add valid child node
+ node = root.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, createSimpleNodeContext("name"),
+ "my:nodeType1");
+ assertNoValidationErrors(node);
+
+ // add auto-created child node
+ nodeContext = createSimpleNodeContext("my:autoCreatedChild1");
+ childNode = node.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR,
+ nodeContext, "my:nodeType2");
+ assertValidationMessage(childNode, new ValidationMessage(ValidationMessageSeverity.ERROR,
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_CHILD_NODE_NOT_ALLOWED, "my:autoCreatedChild1", "my:nodeType2",
+ "my:nodeType1",
+ JcrNodeTypeMetaDataImpl.CONSTRAINT_CHILD_NODE_AUTO_CREATED),
+ nodeContext));
+
+ // below that add child node which is not allowed
+ nodeContext = createSimpleNodeContext("name2");
+ childNode = node.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, nodeContext,
+ "my:nodeType1");
+ assertValidationMessage(childNode, new ValidationMessage(ValidationMessageSeverity.ERROR,
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_CHILD_NODE_NOT_ALLOWED, "name2", "my:nodeType1", "my:nodeType1",
+ JcrNodeTypeMetaDataImpl.CONSTRAINT_CHILD_NODE_NOT_ALLOWED),
+ nodeContext));
+ }
+
+ @Test
+ public void testValidateMandatoryChildNode() throws IllegalNameException, NoSuchNodeTypeException, RepositoryException,
+ IOException, ParseException {
+ try (InputStream input = this.getClass().getResourceAsStream("/simple-restricted-nodetypes.cnd");
+ Reader reader = new InputStreamReader(input, StandardCharsets.US_ASCII)) {
+ ntManagerProvider.registerNodeTypes(reader);
+ }
+
+ // add valid node
+ JcrNodeTypeMetaData node = root.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, createSimpleNodeContext("name"),
+ "my:nodeType1");
+ assertNoValidationErrors(node);
+
+ DefaultWorkspaceFilter filter = new DefaultWorkspaceFilter();
+
+ // mandatory child node missing outside filter
+ Collection<ValidationMessage> messages = node.finalizeValidation(ntManagerProvider.getNamePathResolver(),
+ ValidationMessageSeverity.ERROR, filter);
+ ValidationExecutorTest.assertViolation(messages, new ValidationMessage(ValidationMessageSeverity.ERROR,
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_MANDATORY_UNCONTAINED_CHILD_NODE_MISSING, "my:namedChild1 [my:nodeType1]", "my:nodeType1",
+ "/name")));
+
+ node = root.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, createSimpleNodeContext("name2"),
+ "my:nodeType1");
+
+ // mandatory child node missing inside filter
+ filter.add(new PathFilterSet("/"));
+ messages = node.finalizeValidation(ntManagerProvider.getNamePathResolver(), ValidationMessageSeverity.ERROR, filter);
+ ValidationExecutorTest.assertViolation(messages, new ValidationMessage(ValidationMessageSeverity.ERROR,
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_MANDATORY_CHILD_NODE_MISSING, "my:namedChild1 [my:nodeType1]", "my:nodeType1",
+ "/name2")));
+
+ // calling a second time will not lead to anything
+ messages = node.finalizeValidation(ntManagerProvider.getNamePathResolver(), ValidationMessageSeverity.ERROR, filter);
+ Assert.assertThat(messages, AnyValidationMessageMatcher.noValidationInCollection());
+
+ // now add mandatory child node
+ node = root.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, createSimpleNodeContext("name3"),
+ "my:nodeType1");
+
+ node.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, createSimpleNodeContext("my:namedChild1"),
+ "my:nodeType1");
+ messages = node.finalizeValidation(ntManagerProvider.getNamePathResolver(), ValidationMessageSeverity.ERROR,
+ new DefaultWorkspaceFilter());
+ Assert.assertThat(messages, AnyValidationMessageMatcher.noValidationInCollection());
+
+ // add arbitrary property to root
+ root.addProperty(createSimpleNodeContext("/"), ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, "property", false,
+ ValueFactoryImpl.getInstance().createValue("foo"));
+ assertNoValidationErrors(root);
+
+ NodeContext nodeContext = createSimpleNodeContext("nodeForMandatoryProperties");
+ node = root.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, nodeContext, "my:nodeType2");
+ assertNoValidationErrors(node);
+ messages = node.finalizeValidation(ntManagerProvider.getNamePathResolver(), ValidationMessageSeverity.ERROR, filter);
+ ValidationExecutorTest.assertViolation(messages, new ValidationMessage(ValidationMessageSeverity.ERROR,
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_MANDATORY_PROPERTY_MISSING, "my:mandatoryProperty", "my:nodeType2",
+ "/nodeForMandatoryProperties")));
+
+ nodeContext = createSimpleNodeContext("nodeForMandatoryProperties2");
+ node = root.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, nodeContext, "my:nodeType2");
+ assertNoValidationErrors(node);
+ node.addProperty(nodeContext, ntManagerProvider.getNamePathResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ "my:mandatoryProperty", false, ValueFactoryImpl.getInstance().createValue("foo"));
+ messages = node.finalizeValidation(ntManagerProvider.getNamePathResolver(), ValidationMessageSeverity.ERROR, filter);
+ ValidationExecutorTest.assertViolation(messages, new ValidationMessage(ValidationMessageSeverity.ERROR,
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_MANDATORY_PROPERTY_WITH_WRONG_TYPE, "my:mandatoryProperty", "String", "Date",
+ "my:nodeType2", "/nodeForMandatoryProperties2")));
+ }
+
+ @Test(expected = IllegalNameException.class)
+ public void testAddPropertyWithUndeclaredNamespace() throws RepositoryException {
+ root.addProperty(createSimpleNodeContext("/"), ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ "invalid:property", false, ValueFactoryImpl.getInstance().createValue("foo"));
+ }
+
+ @Test
+ public void testAddProperty() throws RepositoryException, ParseException, IOException {
+ try (InputStream input = this.getClass().getResourceAsStream("/simple-restricted-nodetypes.cnd");
+ Reader reader = new InputStreamReader(input,
+ StandardCharsets.US_ASCII)) {
+ ntManagerProvider.registerNodeTypes(reader);
+ }
+
+ NodeContext nodeContext = createSimpleNodeContext("/");
+ // add arbitrary property to root
+ root.addProperty(nodeContext, ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, "property", false,
+ ValueFactoryImpl.getInstance().createValue("foo"));
+ assertNoValidationErrors(root);
+
+ JcrNodeTypeMetaData node = root.addChildNode(ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, createSimpleNodeContext("child"),
+ "my:nodeType3");
+ assertNoValidationErrors(node);
+
+ // not allowed (wrong type)
+ node.addProperty(nodeContext, ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, "property", false,
+ ValueFactoryImpl.getInstance().createValue("foo"));
+ assertValidationMessage(node,
+ new ValidationMessage(ValidationMessageSeverity.ERROR,
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_PROPERTY_NOT_ALLOWED, "property",
+ "String", "my:nodeType3", JcrNodeTypeMetaDataImpl.CONSTRAINT_PROPERTY_NOT_ALLOWED),
+ nodeContext));
+
+ // protected but nevertheless allowed
+ node.addProperty(nodeContext, ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, "jcr:primaryType", false,
+ ValueFactoryImpl.getInstance().createValue("foo"));
+ assertNoValidationErrors(node);
+
+ // protected
+ node.addProperty(nodeContext, ntManagerProvider.getNamePathResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ "my:protected", false, ValueFactoryImpl.getInstance().createValue("foo"));
+ assertValidationMessage(node,
+ new ValidationMessage(ValidationMessageSeverity.ERROR, String.format(JcrNodeTypeMetaDataImpl.MESSAGE_PROPERTY_NOT_ALLOWED,
+ "my:protected", "String", "my:nodeType3", JcrNodeTypeMetaDataImpl.CONSTRAINT_PROPERTY_PROTECTED), nodeContext));
+
+ // multi value where single value is required
+ node.addProperty(nodeContext, ntManagerProvider.getNamePathResolver(),
+ ntManagerProvider.getEffectiveNodeTypeProvider(), ntManagerProvider.getNodeTypeDefinitionProvider(),
+ ntManagerProvider.getItemDefinitionProvider(), ValidationMessageSeverity.ERROR, "my:property1", true,
+ ValueFactoryImpl.getInstance().createValue("foo"), ValueFactoryImpl.getInstance().createValue("bar"));
+ assertValidationMessage(node,
+ new ValidationMessage(ValidationMessageSeverity.ERROR, String.format(JcrNodeTypeMetaDataImpl.MESSAGE_PROPERTY_NOT_ALLOWED,
+ "my:property1", "String", "my:nodeType3", JcrNodeTypeMetaDataImpl.CONSTRAINT_PROPERTY_NOT_ALLOWED), nodeContext));
+
+ // constrained property
+ node.addProperty(nodeContext, ntManagerProvider.getNamePathResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ "my:constrainedStringProperty", false, ValueFactoryImpl.getInstance().createValue("prefix1foo"));
+ assertNoValidationErrors(root);
+
+ node.addProperty(nodeContext, ntManagerProvider.getNamePathResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ "my:constrainedStringProperty", false, ValueFactoryImpl.getInstance().createValue("foosuffix1"));
+ assertNoValidationErrors(root);
+
+ node.addProperty(nodeContext, ntManagerProvider.getNamePathResolver(), ntManagerProvider.getEffectiveNodeTypeProvider(),
+ ntManagerProvider.getNodeTypeDefinitionProvider(), ntManagerProvider.getItemDefinitionProvider(),
+ ValidationMessageSeverity.ERROR,
+ "my:constrainedStringProperty", false, ValueFactoryImpl.getInstance().createValue("foo"));
+ assertValidationMessage(node,
+ new ValidationMessage(ValidationMessageSeverity.ERROR, String.format(JcrNodeTypeMetaDataImpl.MESSAGE_PROPERTY_NOT_ALLOWED,
+ "my:constrainedStringProperty", "String", "my:nodeType3",
+ String.format(JcrNodeTypeMetaDataImpl.CONSTRAINT_PROPERTY_VALUE,
+ "'foo' does not satisfy the constraint '.*suffix1'")),
+ nodeContext));
+ }
+
+ private static void assertNoValidationErrors(JcrNodeTypeMetaData node) {
+ Collection<ValidationMessage> messages = new ArrayList<>();
+ node.fetchAndClearValidationMessages(messages);
+ Assert.assertThat(messages, Matchers.empty());
+ }
+
+ private static void assertValidationMessage(JcrNodeTypeMetaData node, ValidationMessage... expectedMessages) {
+ Collection<ValidationMessage> actualMessages = new ArrayList<>();
+ node.fetchAndClearValidationMessages(actualMessages);
+ Assert.assertThat(actualMessages, Matchers.contains(expectedMessages));
+ }
+
+}
diff --git a/vault-validation/src/test/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidatorTest.java b/vault-validation/src/test/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidatorTest.java
index fb5af86..3b6197f 100644
--- a/vault-validation/src/test/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidatorTest.java
+++ b/vault-validation/src/test/java/org/apache/jackrabbit/vault/validation/spi/impl/nodetype/NodeTypeValidatorTest.java
@@ -30,7 +30,6 @@ import javax.jcr.nodetype.NodeType;
import org.apache.jackrabbit.JcrConstants;
import org.apache.jackrabbit.commons.cnd.ParseException;
-import org.apache.jackrabbit.jcr2spi.nodetype.EffectiveNodeType;
import org.apache.jackrabbit.spi.commons.name.NameConstants;
import org.apache.jackrabbit.vault.fs.api.WorkspaceFilter;
import org.apache.jackrabbit.vault.fs.config.ConfigurationException;
@@ -65,9 +64,7 @@ public class NodeTypeValidatorTest {
static NodeTypeValidator createValidator(WorkspaceFilter filter, String defaultNodeType)
throws IOException, RepositoryException, ParseException {
NodeTypeManagerProvider ntManagerProvider = new NodeTypeManagerProvider();
- EffectiveNodeType defaultEffectiveNodeType = ntManagerProvider.getEffectiveNodeTypeProvider()
- .getEffectiveNodeType(ntManagerProvider.getNameResolver().getQName(defaultNodeType));
- return new NodeTypeValidator(filter, ntManagerProvider, defaultEffectiveNodeType, ValidationMessageSeverity.ERROR,
+ return new NodeTypeValidator(filter, ntManagerProvider, NameConstants.NT_FOLDER, ValidationMessageSeverity.ERROR,
ValidationMessageSeverity.WARN);
}
@@ -91,24 +88,44 @@ public class NodeTypeValidatorTest {
node = new DocViewNode("test", "test", null, props, null, "nt:folder");
ValidationExecutorTest.assertViolation(validator.validate(node, nodeContext, false),
new ValidationMessage(ValidationMessageSeverity.ERROR,
- String.format(NodeTypeValidator.MESSAGE_PROPERTY_NOT_ALLOWED, property, "nt:folder",
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_PROPERTY_NOT_ALLOWED, property, "nt:folder",
"No property definition found for name!")));
}
@Test
+ public void testUncontainedRootNode() {
+ NodeContext nodeContext = new NodeContextImpl("/", Paths.get("jcr_root"), Paths.get(""));
+
+ Map<String, DocViewProperty> props = new HashMap<>();
+ props.put(NameConstants.JCR_PRIMARYTYPE.toString(),
+ new DocViewProperty(NameConstants.JCR_PRIMARYTYPE.toString(),
+ new String[] { "rep:root" }, false, PropertyType.STRING));
+ props.put(NameConstants.JCR_MIXINTYPES.toString(),
+ new DocViewProperty(NameConstants.JCR_MIXINTYPES.toString(),
+ new String[] { "rep:AccessControllable", "rep:RepoAccessControllable" }, true, PropertyType.STRING));
+ DocViewNode node = new DocViewNode("jcr:root", "jcr:root", null, props, null, "rep:root");
+
+ Assert.assertThat(validator.validate(node, nodeContext, true), AnyValidationMessageMatcher.noValidationInCollection());
+ Assert.assertThat(validator.validateEnd(node, nodeContext, true), AnyValidationMessageMatcher.noValidationInCollection());
+ }
+
+ @Test
public void testInvalidChildNodeTypeBelowDefault() {
- NodeContext nodeContext = new NodeContextImpl("/apps/test/node4", Paths.get("node4"), Paths.get(""));
+ NodeContext nodeContext = new NodeContextImpl("/apps", Paths.get("apps"), Paths.get(""));
+ Assert.assertThat(validator.validateJcrPath(nodeContext, true, false), AnyValidationMessageMatcher.noValidationInCollection());
+ nodeContext = new NodeContextImpl("/apps/test", Paths.get("apps", "test"), Paths.get(""));
Map<String, DocViewProperty> props = new HashMap<>();
props.put(NameConstants.JCR_PRIMARYTYPE.toString(), new DocViewProperty(NameConstants.JCR_PRIMARYTYPE.toString(),
new String[] { JcrConstants.NT_UNSTRUCTURED }, false, PropertyType.STRING));
+
// nt:unstructured below nt:folder is not allowed
DocViewNode node = new DocViewNode("jcr:root", "jcr:root", null, props, null, JcrConstants.NT_UNSTRUCTURED);
ValidationExecutorTest.assertViolation(validator.validate(node, nodeContext, false),
new ValidationMessage(ValidationMessageSeverity.ERROR,
- String.format(NodeTypeValidator.MESSAGE_CHILD_NODE_OF_NOT_CONTAINED_PARENT_POTENTIALLY_NOT_ALLOWED,
- "jcr:root [nt:unstructured]", JcrConstants.NT_FOLDER,
- "Could not find matching child node definition in parent's node type")));
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_CHILD_NODE_OF_NOT_CONTAINED_PARENT_POTENTIALLY_NOT_ALLOWED,
+ "test", "nt:unstructured", JcrConstants.NT_FOLDER,
+ "Node type does not allow arbitrary child nodes and does not allow this specific name and node type either!"), nodeContext));
}
@Test
@@ -121,10 +138,10 @@ public class NodeTypeValidatorTest {
DocViewNode node = new DocViewNode("jcr:root", "jcr:root", null, props, null, JcrConstants.NT_FILE);
Assert.assertThat(validator.validate(node, nodeContext, false), AnyValidationMessageMatcher.noValidationInCollection());
- ValidationExecutorTest.assertViolation(validator.validateEnd(node, nodeContext, false),
+ ValidationExecutorTest.assertViolation(validator.done(),
new ValidationMessage(ValidationMessageSeverity.ERROR,
- String.format(NodeTypeValidator.MESSAGE_MANDATORY_CHILD_NODE_MISSING,
- "jcr:content [nt:base]")));
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_MANDATORY_CHILD_NODE_MISSING,
+ "jcr:content [nt:base]", "nt:file", "/apps/test/node4")));
}
@Test
@@ -140,11 +157,11 @@ public class NodeTypeValidatorTest {
DocViewNode node = new DocViewNode("jcr:root", "jcr:root", null, props, null, JcrConstants.NT_FILE);
ValidationExecutorTest.assertViolation(validator.validate(node, nodeContext, false),
new ValidationMessage(ValidationMessageSeverity.ERROR,
- String.format(NodeTypeValidator.MESSAGE_PROPERTY_NOT_ALLOWED, prop, JcrConstants.NT_FILE,
- "No property definition found for name!")));
+ String.format(JcrNodeTypeMetaDataImpl.MESSAGE_PROPERTY_NOT_ALLOWED, "invalid-prop", "String", JcrConstants.NT_FILE,
+ "No applicable property definition found for name and type!"), nodeContext));
}
- @Test(expected = IllegalStateException.class)
+ @Test
public void testPropertyWitInconvertibleValue() {
NodeContext nodeContext = new NodeContextImpl("/apps/test/node4", Paths.get("node4"), Paths.get(""));
@@ -155,11 +172,14 @@ public class NodeTypeValidatorTest {
new String[] { JcrConstants.NT_FILE }, false, PropertyType.STRING));
// nt:file is only supposed to have jcr:created property
DocViewNode node = new DocViewNode("jcr:root", "jcr:root", null, props, null, JcrConstants.NT_FILE);
- validator.validate(node, nodeContext, false);
+ ValidationExecutorTest.assertViolation(validator.validate(node, nodeContext, false),
+ new ValidationMessage(ValidationMessageSeverity.ERROR,
+ String.format(NodeTypeValidator.MESSAGE_INVALID_PROPERTY_VALUE, Property.JCR_CREATED,
+ "not a valid date format: some-invalid-value")));
}
@Test
- public void testUnknownNamespace() {
+ public void testUnknownNamespaceInType() {
NodeContext nodeContext = new NodeContextImpl("/apps/test/node4", Paths.get("node4"), Paths.get(""));
Map<String, DocViewProperty> props = new HashMap<>();
@@ -172,9 +192,23 @@ public class NodeTypeValidatorTest {
ValidationExecutorTest.assertViolation(validator.validate(node, nodeContext, false),
new ValidationMessage(ValidationMessageSeverity.WARN,
String.format(NodeTypeValidator.MESSAGE_UNKNOWN_NODE_TYPE_OR_NAMESPACE,
- "Invalid primary type sling:Folder: 'sling: is not a registered namespace prefix.'")));
+ "Invalid primary type 'sling:Folder': sling: is not a registered namespace prefix."), nodeContext));
+ }
+
+ @Test
+ public void testUnknownNamespaceInName() {
+ NodeContext nodeContext = new NodeContextImpl("/apps/test/cq:dialog", Paths.get("_cq_dialog"), Paths.get(""));
+ Map<String, DocViewProperty> props = new HashMap<>();
+ props.put(NameConstants.JCR_PRIMARYTYPE.toString(), new DocViewProperty(NameConstants.JCR_PRIMARYTYPE.toString(),
+ new String[] { "nt:Folder" }, false, PropertyType.STRING));
+ DocViewNode node = new DocViewNode("cq:dialog", "cq:dialog", null, props, null, "nt:folder");
+ ValidationExecutorTest.assertViolation(validator.validate(node, nodeContext, false),
+ new ValidationMessage(ValidationMessageSeverity.WARN,
+ String.format(NodeTypeValidator.MESSAGE_UNKNOWN_NODE_TYPE_OR_NAMESPACE,
+ "Invalid node name 'cq:dialog': cq: is not a registered namespace prefix."), nodeContext));
}
+
@Test
public void testExistenceOfPrimaryNodeTypes() throws IOException, ConfigurationException, RepositoryException, ParseException {
validator = createValidator(filter, NodeType.NT_UNSTRUCTURED);
diff --git a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/package-info.java b/vault-validation/src/test/resources/simple-restricted-nodetypes.cnd
similarity index 52%
copy from vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/package-info.java
copy to vault-validation/src/test/resources/simple-restricted-nodetypes.cnd
index 5a64445..278b370 100644
--- a/vault-validation/src/main/java/org/apache/jackrabbit/vault/validation/spi/package-info.java
+++ b/vault-validation/src/test/resources/simple-restricted-nodetypes.cnd
@@ -14,11 +14,25 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+// https://jackrabbit.apache.org/jcr/node-type-notation.html
+<'my'='http://example.com/mynamespace2'>
-/**
- * The FileVault validation framework SPI. Provides classes/interfaces to implement validators on FileVault packages.
- */
-@Version("1.2.0")
-package org.apache.jackrabbit.vault.validation.spi;
-import org.osgi.annotation.versioning.Version;
+[my:nodeType1]
+ + my:namedChild1 (my:nodeType1) mandatory
+ + my:autoCreatedChild1 (my:nodeType2) = my:nodeType2 autocreated mandatory
+ + * (my:nodeType2) mandatory
+
+[my:nodeType2]
+ - my:property2 (String)
+ - my:mandatoryProperty (Date) mandatory
+ - *
+
+[my:nodeType3]
+ - my:property1 (String)
+ // https://docs.adobe.com/docs/en/spec/jcr/2.0/3_Repository_Model.html#3.7.3.6%20Value%20Constraints
+ - my:constrainedStringProperty (String) < "prefix1.*",".*suffix1"
+ - my:protected (String) protected
+ - my:dateProperty (Date)
+ - my:mandatoryProperty (String) mandatory
+ - my:autoCreatedProperty (String) autocreated
\ No newline at end of file