protected Workspace(Session jcrSession) throws RepositoryException {
this.session = jcrSession;
this.name = this.session.getWorkspace().getName();
ExecutionContext connectorContext = getExecutionContext();
NamespaceRegistry connectorRegistry = connectorContext.getNamespaceRegistry();
this.context =
connectorContext.with(
new JcrNamespaceRegistry(getSourceName(), this.session, connectorRegistry));
this.factories = context.getValueFactories();
this.propertyFactory = context.getPropertyFactory();
this.nameFactory = this.factories.getNameFactory();
this.stringFactory = this.factories.getStringFactory();
this.jcrValueFactory = this.session.getValueFactory();
}
protected Map<Name, Property> load(File propertiesFile, ExecutionContext context)
throws RepositorySourceException {
if (!propertiesFile.exists() || !propertiesFile.canRead()) return NO_PROPERTIES_MAP;
try {
String content = IoUtil.read(propertiesFile);
ValueFactories factories = context.getValueFactories();
PropertyFactory propFactory = context.getPropertyFactory();
Map<Name, Property> result = new HashMap<Name, Property>();
for (String line : StringUtil.splitLines(content)) {
// Parse each line ...
Property property = parse(line, factories, propFactory);
if (property != null) {
result.put(property.getName(), property);
}
}
return result;
} catch (IOException e) {
throw new RepositorySourceException(sourceName, e);
}
}
/**
* {@inheritDoc}
*
* @see org.modeshape.jcr.security.AuthenticationProvider#authenticate(javax.jcr.Credentials,
* java.lang.String, java.lang.String, org.modeshape.graph.ExecutionContext, java.util.Map)
*/
public ExecutionContext authenticate(
Credentials credentials,
String repositoryName,
String workspaceName,
ExecutionContext repositoryContext,
Map<String, Object> sessionAttributes) {
if (credentials instanceof TestSecurityContextCredentials) {
TestSecurityContextCredentials scc = (TestSecurityContextCredentials) credentials;
return repositoryContext.with(contextFor(scc));
}
return null;
}
protected Set<Name> write(
File propertiesFile, ExecutionContext context, Map<Name, Property> properties)
throws RepositorySourceException {
if (properties.isEmpty()) {
if (propertiesFile.exists()) {
// Delete the file ...
propertiesFile.delete();
}
return Collections.emptySet();
}
Set<Name> names = new HashSet<Name>();
try {
ValueFactory<String> strings = context.getValueFactories().getStringFactory();
Writer fileWriter = new FileWriter(propertiesFile);
try {
// Write the primary type first ...
Property primaryType = properties.get(JcrLexicon.PRIMARY_TYPE);
if (primaryType != null) {
write(primaryType, fileWriter, strings);
names.add(primaryType.getName());
}
// Then write the mixin types ...
Property mixinTypes = properties.get(JcrLexicon.MIXIN_TYPES);
if (mixinTypes != null) {
write(mixinTypes, fileWriter, strings);
names.add(mixinTypes.getName());
}
// Then write the UUID ...
Property uuid = properties.get(JcrLexicon.UUID);
if (uuid != null) {
write(uuid, fileWriter, strings);
names.add(uuid.getName());
}
// Then all the others ...
for (Property property : properties.values()) {
if (property == primaryType || property == mixinTypes || property == uuid) continue;
write(property, fileWriter, strings);
names.add(property.getName());
}
} finally {
fileWriter.close();
}
} catch (IOException e) {
throw new RepositorySourceException(sourceName, e);
}
return names;
}
@Override
public QueryResults query(
String workspaceName,
QueryCommand query,
Schemata schemata,
PlanHints hints,
Map<String, Object> variables) {
TypeSystem typeSystem = context.getValueFactories().getTypeSystem();
SearchEngineProcessor processor = searchEngine.createProcessor(context, null, true);
try {
QueryContext context =
new GraphQueryContext(
schemata,
typeSystem,
hints,
new SimpleProblems(),
variables,
processor,
workspaceName);
return queryEngine.execute(context, query);
} finally {
processor.close();
}
}
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;
}