public RepositoryDefinition<ReturnType> addNodeTypes(URL url) {
CheckArg.isNotNull(url, "url");
// Obtain the stream ...
InputStream stream = null;
boolean foundError = false;
try {
Set<Namespace> namespacesBefore =
batch.getGraph().getContext().getNamespaceRegistry().getNamespaces();
stream = url.openStream();
CndImporter importer = createCndImporter();
importer.importFrom(stream, getProblems(), url.toString());
if (getProblems().hasErrors()) {
for (Problem problem : getProblems()) {
if (problem.getStatus() == Status.ERROR) {
throw new ModeShapeConfigurationException(problem.getThrowable());
}
}
}
// Record any new namespaces added by this import ...
registerNewNamespaces(namespacesBefore);
} catch (IOException e) {
foundError = true;
throw new ModeShapeConfigurationException(e);
} finally {
if (stream != null) {
try {
stream.close();
} catch (IOException e) {
if (!foundError) {
throw new ModeShapeConfigurationException(e);
}
}
}
}
return this;
}
protected JcrRepository doCreateJcrRepository(String repositoryName)
throws RepositoryException, PathNotFoundException {
RepositoryConnectionFactory connectionFactory = getRepositoryConnectionFactory();
Map<String, String> descriptors = new HashMap<String, String>();
Map<Option, String> options = new HashMap<Option, String>();
// Read the subgraph that represents the repository ...
PathFactory pathFactory = getExecutionContext().getValueFactories().getPathFactory();
Path repositoriesPath =
pathFactory.create(configuration.getPath(), ModeShapeLexicon.REPOSITORIES);
Path repositoryPath = pathFactory.create(repositoriesPath, repositoryName);
Name repoName =
getExecutionContext().getValueFactories().getNameFactory().create(repositoryName);
Graph configuration = null;
Subgraph subgraph = getConfigurationSubgraph(false);
// Read the options ...
Path optionsPath =
pathFactory.createRelativePath(
ModeShapeLexicon.REPOSITORIES, repoName, ModeShapeLexicon.OPTIONS);
Node optionsNode = subgraph.getNode(optionsPath);
if (optionsNode != null) {
for (Location optionLocation : optionsNode.getChildren()) {
Node optionNode = subgraph.getNode(optionLocation);
Path.Segment segment = optionLocation.getPath().getLastSegment();
Property valueProperty = optionNode.getProperty(ModeShapeLexicon.VALUE);
if (valueProperty == null) {
log.warn(JcrI18n.noOptionValueProvided, segment.getName().getLocalName());
continue;
}
Option option = Option.findOption(segment.getName().getLocalName());
if (option == null) {
log.warn(JcrI18n.invalidOptionProvided, segment.getName().getLocalName());
continue;
}
options.put(option, valueProperty.getFirstValue().toString());
}
}
// Disable the derived content removal option if not explicitly set and no sequencers ...
if (!options.containsKey(Option.REMOVE_DERIVED_CONTENT_WITH_ORIGINAL)
&& getSequencingService().getSequencers().isEmpty()) {
options.put(Option.REMOVE_DERIVED_CONTENT_WITH_ORIGINAL, Boolean.FALSE.toString());
}
// Read the descriptors ...
Path descriptorsPath =
pathFactory.createRelativePath(
ModeShapeLexicon.REPOSITORIES, repoName, ModeShapeLexicon.DESCRIPTORS);
Node descriptorsNode = subgraph.getNode(descriptorsPath);
if (descriptorsNode != null) {
for (Location descriptorLocation : descriptorsNode.getChildren()) {
Node optionNode = subgraph.getNode(descriptorLocation);
Path.Segment segment = descriptorLocation.getPath().getLastSegment();
Property valueProperty = optionNode.getProperty(ModeShapeLexicon.VALUE);
if (valueProperty == null) continue;
descriptors.put(segment.getName().getLocalName(), valueProperty.getFirstValue().toString());
}
}
// Read the namespaces ...
ExecutionContext context = getExecutionContext();
Path namespacesPath =
pathFactory.createRelativePath(
ModeShapeLexicon.REPOSITORIES, repoName, ModeShapeLexicon.NAMESPACES);
Node namespacesNode = subgraph.getNode(namespacesPath);
descriptors.put(org.modeshape.jcr.api.Repository.REPOSITORY_NAME, repositoryName);
if (namespacesNode != null) {
configuration = getConfigurationGraph();
GraphNamespaceRegistry registry =
new GraphNamespaceRegistry(
configuration,
namespacesNode.getLocation().getPath(),
ModeShapeLexicon.URI,
ModeShapeLexicon.GENERATED);
context = context.with(registry);
}
// Get the name of the source ...
Path repoPath = pathFactory.createRelativePath(ModeShapeLexicon.REPOSITORIES, repoName);
Node repoNode = subgraph.getNode(repoPath);
if (repoNode == null) {
// There is no repository with the supplied name ...
throw new PathNotFoundException(
Location.create(repoPath),
repositoriesPath,
JcrI18n.repositoryDoesNotExist.text(readable(repoName)));
}
Property property = repoNode.getProperty(ModeShapeLexicon.SOURCE_NAME);
if (property == null || property.isEmpty()) {
if (configuration == null) configuration = getConfigurationGraph();
String readableName = readable(ModeShapeLexicon.SOURCE_NAME);
String readablePath = readable(subgraph.getLocation());
String msg =
JcrI18n.propertyNotFoundOnNode.text(
readableName, readablePath, configuration.getCurrentWorkspaceName());
throw new RepositoryException(msg);
}
String sourceName =
context.getValueFactories().getStringFactory().create(property.getFirstValue());
// Verify the sourc exists ...
RepositorySource source = getRepositorySource(sourceName);
if (source == null) {
throw new RepositoryException(
JcrI18n.repositoryReferencesNonExistantSource.text(repositoryName, sourceName));
}
// Read the initial content ...
String initialContentForNewWorkspaces = null;
for (Location initialContentLocation : repoNode.getChildren(ModeShapeLexicon.INITIAL_CONTENT)) {
Node initialContent = subgraph.getNode(initialContentLocation);
if (initialContent == null) continue;
// Determine where to load the initial content from ...
Property contentReference = initialContent.getProperty(ModeShapeLexicon.CONTENT);
if (contentReference == null || contentReference.isEmpty()) {
if (configuration == null) configuration = getConfigurationGraph();
String readableName = readable(ModeShapeLexicon.CONTENT);
String readablePath = readable(initialContentLocation);
String msg =
JcrI18n.propertyNotFoundOnNode.text(
readableName, readablePath, configuration.getCurrentWorkspaceName());
throw new RepositoryException(msg);
}
String contentRef = string(contentReference.getFirstValue());
// Determine which workspaces this should apply to ...
Property workspaces = initialContent.getProperty(ModeShapeLexicon.WORKSPACES);
if (workspaces == null || workspaces.isEmpty()) {
if (configuration == null) configuration = getConfigurationGraph();
String readableName = readable(ModeShapeLexicon.WORKSPACES);
String readablePath = readable(initialContentLocation);
String msg =
JcrI18n.propertyNotFoundOnNode.text(
readableName, readablePath, configuration.getCurrentWorkspaceName());
throw new RepositoryException(msg);
}
// Load the initial content into a transient source ...
XmlFileRepositorySource initialContentSource = new XmlFileRepositorySource();
initialContentSource.setName("Initial content for " + repositoryName);
initialContentSource.setContentLocation(contentRef);
Graph initialContentGraph = Graph.create(initialContentSource, context);
Graph sourceGraph = Graph.create(sourceName, connectionFactory, context);
// And initialize the source with the content (if not already there) ...
for (Object value : workspaces) {
String workspaceName = string(value);
if (workspaceName != null && workspaceName.trim().length() != 0) {
// Load the content into the workspace with this name ...
sourceGraph.useWorkspace(workspaceName);
try {
sourceGraph.merge(initialContentGraph);
} catch (RuntimeException e) {
throw new RepositoryException(
JcrI18n.unableToImportInitialContent.text(readable(repoName), contentRef), e);
}
}
}
// Determine if this initial content should apply to new workspaces ...
Property applyToNewWorkspaces =
initialContent.getProperty(ModeShapeLexicon.APPLY_TO_NEW_WORKSPACES);
if (applyToNewWorkspaces != null
&& !applyToNewWorkspaces.isEmpty()
&& isTrue(applyToNewWorkspaces.getFirstValue())) {
initialContentForNewWorkspaces =
contentRef; // may overwrite the value if seen more than once!
}
}
// Find the capabilities ...
RepositorySourceCapabilities capabilities = source.getCapabilities();
// Create the repository ...
JcrRepository repository =
new JcrRepository(
context,
connectionFactory,
sourceName,
getRepositoryService().getRepositoryLibrary(),
capabilities,
descriptors,
options,
initialContentForNewWorkspaces);
// Register all the the node types ...
Path nodeTypesPath =
pathFactory.createRelativePath(
ModeShapeLexicon.REPOSITORIES, repoName, JcrLexicon.NODE_TYPES);
Node nodeTypesNode = subgraph.getNode(nodeTypesPath);
if (nodeTypesNode != null) {
boolean needToRefreshSubgraph = false;
if (configuration == null) configuration = getConfigurationGraph();
// Expand any references to a CND file
Property resourceProperty = nodeTypesNode.getProperty(ModeShapeLexicon.RESOURCE);
if (resourceProperty != null) {
ClassLoader classLoader = this.context.getClassLoader();
for (Object resourceValue : resourceProperty) {
String resources =
this.context.getValueFactories().getStringFactory().create(resourceValue);
for (String resource : resources.split("\\s*,\\s*")) {
Graph.Batch batch = configuration.batch();
GraphBatchDestination destination = new GraphBatchDestination(batch);
Path nodeTypesAbsPath = pathFactory.create(repositoryPath, JcrLexicon.NODE_TYPES);
CndImporter importer = new CndImporter(destination, nodeTypesAbsPath, true, false);
InputStream is = IoUtil.getResourceAsStream(resource, classLoader, getClass());
Problems cndProblems = new SimpleProblems();
if (is == null) {
String msg =
JcrI18n.unableToFindNodeTypeDefinitionsOnClasspathOrFileOrUrl.text(resource);
throw new RepositoryException(msg);
}
try {
importer.importFrom(is, cndProblems, resource);
batch.execute();
needToRefreshSubgraph = true;
} catch (IOException ioe) {
String msg = JcrI18n.errorLoadingNodeTypeDefintions.text(resource, ioe.getMessage());
throw new RepositoryException(msg, ioe);
}
if (!cndProblems.isEmpty()) {
// Add any warnings or information to this engine's list ...
getProblems().addAll(cndProblems);
if (cndProblems.hasErrors()) {
String msg = null;
Throwable cause = null;
for (Problem problem : cndProblems) {
if (problem.getStatus() == Status.ERROR) {
msg = problem.getMessageString();
cause = problem.getThrowable();
break;
}
}
throw new RepositoryException(
JcrI18n.errorLoadingNodeTypeDefintions.text(resource, msg), cause);
}
}
}
}
}
// Load any namespaces from the configuration into the repository's context ...
NamespaceRegistry repoRegistry = repository.getExecutionContext().getNamespaceRegistry();
repoRegistry.register(configuration.getContext().getNamespaceRegistry().getNamespaces());
// Re-read the subgraph, in case any new nodes were added
Subgraph nodeTypesSubgraph = subgraph;
if (needToRefreshSubgraph) {
nodeTypesSubgraph =
configuration.getSubgraphOfDepth(4).at(nodeTypesNode.getLocation().getPath());
}
repository
.getRepositoryTypeManager()
.registerNodeTypes(nodeTypesSubgraph, nodeTypesNode.getLocation(), false);
}
return repository;
}