[dna-commits] DNA SVN: r96 - in trunk: dna-common/src/main/java/org/jboss/dna/common/collection and 38 other directories.
dna-commits at lists.jboss.org
dna-commits at lists.jboss.org
Mon Apr 21 22:47:54 EDT 2008
Author: rhauch
Date: 2008-04-21 22:47:53 -0400 (Mon, 21 Apr 2008)
New Revision: 96
Added:
trunk/dna-common/src/main/java/org/jboss/dna/common/collection/Problem.java
trunk/dna-common/src/main/java/org/jboss/dna/common/collection/Problems.java
trunk/dna-repository/
trunk/dna-repository/src/main/java/org/jboss/dna/repository/
trunk/dna-repository/src/main/java/org/jboss/dna/repository/RepositoryI18n.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/
trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChange.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChangeListener.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChanges.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/ObservationService.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/
trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/InvalidRuleSetException.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleService.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleSet.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleSetRepositoryMonitor.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/
trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/InvalidSequencerPathExpression.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/Sequencer.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerConfig.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerException.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerOutputMap.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerPathExpression.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencingService.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/StreamSequencerAdapter.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/
trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/AbstractServiceAdministrator.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/AdministeredService.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/ServiceAdministrator.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/
trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/ExecutionContext.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/JcrTools.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/JndiSessionFactory.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/RepositoryNodePath.java
trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/SessionFactory.java
trunk/dna-repository/src/main/resources/org/jboss/dna/repository/
trunk/dna-repository/src/main/resources/org/jboss/dna/repository/RepositoryI18n.properties
trunk/dna-repository/src/test/java/org/jboss/dna/repository/
trunk/dna-repository/src/test/java/org/jboss/dna/repository/observation/
trunk/dna-repository/src/test/java/org/jboss/dna/repository/observation/NodeChangeTest.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/
trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleInput.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleResult.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleServiceTest.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleSetTest.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/
trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/MockSequencerA.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/MockSequencerB.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencerConfigTest.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencerPathExpressionTest.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencingServiceTest.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/StreamSequencerAdapterTest.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/util/
trunk/dna-repository/src/test/java/org/jboss/dna/repository/util/JndiSessionFactoryTest.java
trunk/dna-repository/src/test/java/org/jboss/dna/repository/util/SimpleExecutionContext.java
trunk/dna-spi/
trunk/dna-spi/.classpath
trunk/dna-spi/.project
trunk/dna-spi/pom.xml
trunk/dna-spi/src/
trunk/dna-spi/src/main/
trunk/dna-spi/src/main/java/
trunk/dna-spi/src/main/java/org/
trunk/dna-spi/src/main/java/org/jboss/
trunk/dna-spi/src/main/java/org/jboss/dna/
trunk/dna-spi/src/main/java/org/jboss/dna/spi/
trunk/dna-spi/src/main/java/org/jboss/dna/spi/sequencers/
trunk/dna-spi/src/main/java/org/jboss/dna/spi/sequencers/SequencerOutput.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/sequencers/StreamSequencer.java
trunk/dna-spi/src/main/resources/
trunk/dna-spi/src/test/
trunk/dna-spi/src/test/java/
trunk/dna-spi/src/test/java/org/
trunk/dna-spi/src/test/java/org/jboss/
trunk/dna-spi/src/test/java/org/jboss/dna/
trunk/dna-spi/src/test/java/org/jboss/dna/spi/
trunk/dna-spi/src/test/java/org/jboss/dna/spi/sequencers/
trunk/dna-spi/src/test/resources/
trunk/dna-spi/src/test/resources/log4j.properties
Removed:
trunk/dna-repository/src/main/java/org/jboss/dna/services/AbstractServiceAdministrator.java
trunk/dna-repository/src/main/java/org/jboss/dna/services/AdministeredService.java
trunk/dna-repository/src/main/java/org/jboss/dna/services/ExecutionContext.java
trunk/dna-repository/src/main/java/org/jboss/dna/services/JndiSessionFactory.java
trunk/dna-repository/src/main/java/org/jboss/dna/services/RepositoryNodePath.java
trunk/dna-repository/src/main/java/org/jboss/dna/services/ServiceAdministrator.java
trunk/dna-repository/src/main/java/org/jboss/dna/services/ServicesI18n.java
trunk/dna-repository/src/main/java/org/jboss/dna/services/SessionFactory.java
trunk/dna-repository/src/main/java/org/jboss/dna/services/observation/
trunk/dna-repository/src/main/java/org/jboss/dna/services/rules/
trunk/dna-repository/src/main/java/org/jboss/dna/services/sequencers/
trunk/dna-repository/src/main/java/org/jboss/dna/services/util/
trunk/dna-repository/src/main/resources/org/jboss/dna/services/
trunk/dna-repository/src/test/java/org/jboss/dna/services/JndiSessionFactoryTest.java
trunk/dna-repository/src/test/java/org/jboss/dna/services/SimpleExecutionContext.java
trunk/dna-repository/src/test/java/org/jboss/dna/services/observation/
trunk/dna-repository/src/test/java/org/jboss/dna/services/rules/
trunk/dna-repository/src/test/java/org/jboss/dna/services/sequencers/
trunk/dna-services/
Modified:
trunk/
trunk/dna-integration-tests/pom.xml
trunk/dna-repository/.project
trunk/dna-repository/pom.xml
trunk/dna-repository/src/test/resources/log4j.properties
trunk/dna-repository/src/test/resources/rule_test.dslr
trunk/pom.xml
trunk/sequencers/dna-sequencer-images/pom.xml
trunk/sequencers/dna-sequencer-images/src/main/java/org/jboss/dna/sequencer/images/ImageMetadataSequencer.java
Log:
DNA-57: Refactor codebase to clearly and cleanly separate SPI and API
Property changes on: trunk
___________________________________________________________________
Name: svn:ignore
+ target
Added: trunk/dna-common/src/main/java/org/jboss/dna/common/collection/Problem.java
===================================================================
--- trunk/dna-common/src/main/java/org/jboss/dna/common/collection/Problem.java (rev 0)
+++ trunk/dna-common/src/main/java/org/jboss/dna/common/collection/Problem.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,120 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.common.collection;
+
+import net.jcip.annotations.Immutable;
+import org.jboss.dna.common.i18n.I18n;
+import org.jboss.dna.common.util.ArgCheck;
+
+/**
+ * @author Randall Hauch
+ */
+ at Immutable
+public class Problem {
+
+ public static final int DEFAULT_CODE = 0;
+
+ public enum Status {
+ ERROR,
+ WARNING,
+ INFO;
+ }
+
+ private final Status status;
+ private final I18n message;
+ private final Object[] parameters;
+ private final Throwable throwable;
+ private final int code;
+ private final String resource;
+ private final String location;
+
+ public Problem( Status status, int code, I18n message, Object... params ) {
+ this(status, code, message, params, null, null, null);
+ }
+
+ public Problem( Status status, int code, I18n message, Object[] params, String resource, String location, Throwable throwable ) {
+ ArgCheck.isNotNull(status, "status");
+ ArgCheck.isNotNull(message, "message");
+ this.status = status;
+ this.code = code;
+ this.message = message;
+ this.parameters = params;
+ this.resource = resource != null ? resource.trim() : null;
+ this.location = location != null ? location.trim() : null;
+ this.throwable = throwable;
+ }
+
+ /**
+ * @return code
+ */
+ public int getCode() {
+ return this.code;
+ }
+
+ /**
+ * @return location
+ */
+ public String getLocation() {
+ return this.location;
+ }
+
+ /**
+ * Get the message written in the current locale.
+ * @return the message
+ */
+ public String getMessageString() {
+ return this.message.text(this.parameters);
+ }
+
+ /**
+ * @return message
+ */
+ public I18n getMessage() {
+ return this.message;
+ }
+
+ public Object[] getParameters() {
+ return this.parameters;
+ }
+
+ /**
+ * @return resource
+ */
+ public String getResource() {
+ return this.resource;
+ }
+
+ /**
+ * @return status
+ */
+ public Status getStatus() {
+ return this.status;
+ }
+
+ /**
+ * @return throwable
+ */
+ public Throwable getThrowable() {
+ return this.throwable;
+ }
+
+}
Added: trunk/dna-common/src/main/java/org/jboss/dna/common/collection/Problems.java
===================================================================
--- trunk/dna-common/src/main/java/org/jboss/dna/common/collection/Problems.java (rev 0)
+++ trunk/dna-common/src/main/java/org/jboss/dna/common/collection/Problems.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,187 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.common.collection;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import net.jcip.annotations.NotThreadSafe;
+import org.jboss.dna.common.i18n.I18n;
+
+/**
+ * @author Randall Hauch
+ */
+ at NotThreadSafe
+public class Problems implements Iterable<Problem> {
+
+ private List<Problem> problems;
+
+ public Problems() {
+ }
+
+ public void addError( I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.ERROR, Problem.DEFAULT_CODE, message, params));
+ }
+
+ public void addError( Throwable throwable, I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.ERROR, Problem.DEFAULT_CODE, message, null, null, throwable));
+ }
+
+ public void addError( I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.ERROR, Problem.DEFAULT_CODE, message, resource, location));
+ }
+
+ public void addError( Throwable throwable, I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.ERROR, Problem.DEFAULT_CODE, message, resource, location, throwable));
+ }
+
+ public void addError( int code, I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.ERROR, code, message));
+ }
+
+ public void addError( Throwable throwable, int code, I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.ERROR, code, message, null, null, throwable));
+ }
+
+ public void addError( int code, I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.ERROR, code, message, resource, location));
+ }
+
+ public void addError( Throwable throwable, int code, I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.ERROR, code, message, resource, location, throwable));
+ }
+
+ public void addWarning( I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.WARNING, Problem.DEFAULT_CODE, message));
+ }
+
+ public void addWarning( Throwable throwable, I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.WARNING, Problem.DEFAULT_CODE, message, null, null, throwable));
+ }
+
+ public void addWarning( I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.WARNING, Problem.DEFAULT_CODE, message, resource, location));
+ }
+
+ public void addWarning( Throwable throwable, I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.WARNING, Problem.DEFAULT_CODE, message, resource, location, throwable));
+ }
+
+ public void addWarning( int code, I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.WARNING, code, message));
+ }
+
+ public void addWarning( Throwable throwable, int code, I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.WARNING, code, message, null, null, throwable));
+ }
+
+ public void addWarning( int code, I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.WARNING, code, message, resource, location));
+ }
+
+ public void addWarning( Throwable throwable, int code, I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.WARNING, code, message, resource, location, throwable));
+ }
+
+ public void addInfo( I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.INFO, Problem.DEFAULT_CODE, message));
+ }
+
+ public void addInfo( Throwable throwable, I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.INFO, Problem.DEFAULT_CODE, message, null, null, throwable));
+ }
+
+ public void addInfo( I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.INFO, Problem.DEFAULT_CODE, message, resource, location));
+ }
+
+ public void addInfo( Throwable throwable, I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.INFO, Problem.DEFAULT_CODE, message, resource, location, throwable));
+ }
+
+ public void addInfo( int code, I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.INFO, code, message));
+ }
+
+ public void addInfo( Throwable throwable, int code, I18n message, Object... params ) {
+ addProblem(new Problem(Problem.Status.INFO, code, message, null, null, throwable));
+ }
+
+ public void addInfo( int code, I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.INFO, code, message, resource, location));
+ }
+
+ public void addInfo( Throwable throwable, int code, I18n message, String resource, String location, Object... params ) {
+ addProblem(new Problem(Problem.Status.INFO, code, message, resource, location, throwable));
+ }
+
+ public boolean hasProblems() {
+ return this.problems != null && this.problems.size() > 0;
+ }
+
+ public boolean hasErrors() {
+ if (this.problems == null) return false;
+ for (Problem problem : this.problems) {
+ if (problem.getStatus() == Problem.Status.ERROR) return true;
+ }
+ return false;
+ }
+
+ public boolean hasWarnings() {
+ if (this.problems == null) return false;
+ for (Problem problem : this.problems) {
+ if (problem.getStatus() == Problem.Status.WARNING) return true;
+ }
+ return false;
+ }
+
+ public boolean hasInfo() {
+ if (this.problems == null) return false;
+ for (Problem problem : this.problems) {
+ if (problem.getStatus() == Problem.Status.INFO) return true;
+ }
+ return false;
+ }
+
+ public boolean isEmpty() {
+ return this.problems == null || this.problems.isEmpty();
+ }
+
+ public int size() {
+ if (this.problems == null) return 0;
+ return this.problems.size();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Iterator<Problem> iterator() {
+ return problems.iterator();
+ }
+
+ protected void addProblem( Problem problem ) {
+ if (problem == null) return;
+ if (problems == null) problems = new LinkedList<Problem>();
+ problems.add(problem);
+ }
+
+}
Modified: trunk/dna-integration-tests/pom.xml
===================================================================
--- trunk/dna-integration-tests/pom.xml 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-integration-tests/pom.xml 2008-04-22 02:47:53 UTC (rev 96)
@@ -31,7 +31,7 @@
</dependency>
<dependency>
<groupId>org.jboss.dna</groupId>
- <artifactId>dna-services</artifactId>
+ <artifactId>dna-repository</artifactId>
<version>0.1-SNAPSHOT</version>
</dependency>
<dependency>
Copied: trunk/dna-repository (from rev 95, trunk/dna-services)
Modified: trunk/dna-repository/.project
===================================================================
--- trunk/dna-services/.project 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/.project 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
- <name>dna-services</name>
+ <name>dna-repository</name>
<comment></comment>
<projects>
</projects>
Modified: trunk/dna-repository/pom.xml
===================================================================
--- trunk/dna-services/pom.xml 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/pom.xml 2008-04-22 02:47:53 UTC (rev 96)
@@ -6,10 +6,10 @@
<version>0.1-SNAPSHOT</version>
</parent>
<!-- The groupId and version values are inherited from parent -->
- <artifactId>dna-services</artifactId>
+ <artifactId>dna-repository</artifactId>
<packaging>jar</packaging>
- <name>JBoss DNA Services</name>
- <description>JBoss DNA Engine library with main service components</description>
+ <name>JBoss DNA Repository</name>
+ <description>JBoss DNA Repository library</description>
<url>http://labs.jboss.org/dna</url>
<!--
Define the dependencies. Note that all version and scopes default to those
@@ -33,6 +33,11 @@
<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.jboss.dna</groupId>
+ <artifactId>dna-spi</artifactId>
+ <version>0.1-SNAPSHOT</version>
+ </dependency>
<!--
Rules
-->
@@ -43,10 +48,12 @@
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-jsr94</artifactId>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-compiler</artifactId>
+ <scope>test</scope>
</dependency>
<!--
Testing (note the scope)
@@ -54,14 +61,17 @@
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.jmock</groupId>
<artifactId>jmock</artifactId>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.jmock</groupId>
<artifactId>jmock-junit4</artifactId>
+ <scope>test</scope>
</dependency>
<!--
Logging (require SLF4J API for compiling, but use Log4J and its SLF4J binding for testing)
@@ -73,10 +83,12 @@
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
+ <scope>test</scope>
</dependency>
<!--
Java Concurrency in Practice annotations
@@ -98,10 +110,12 @@
<dependency>
<groupId>org.apache.jackrabbit</groupId>
<artifactId>jackrabbit-api</artifactId>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.jackrabbit</groupId>
<artifactId>jackrabbit-core</artifactId>
+ <scope>test</scope>
</dependency>
</dependencies>
</project>
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/RepositoryI18n.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/RepositoryI18n.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/RepositoryI18n.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,101 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository;
+
+import org.jboss.dna.common.i18n.I18n;
+
+/**
+ * @author Randall Hauch
+ */
+public final class RepositoryI18n {
+
+ static {
+ try {
+ I18n.initialize(RepositoryI18n.class);
+ } catch (final Exception err) {
+ System.err.println(err);
+ }
+ }
+
+ public static I18n invalidStateString;
+ public static I18n serviceShutdowAndMayNotBeStarted;
+ public static I18n serviceShutdowAndMayNotBePaused;
+ public static I18n unableToFindRepositoryInJndi;
+ public static I18n errorProcessingEvents;
+ public static I18n errorFindingPropertyNameInPropertyAddedEvent;
+ public static I18n errorFindingPropertyNameInPropertyChangedEvent;
+ public static I18n errorFindingPropertyNameInPropertyRemovedEvent;
+
+ public static I18n unableToObtainJsr94RuleAdministrator;
+ public static I18n errorUsingJsr94RuleAdministrator;
+ public static I18n unableToObtainJsr94ServiceProvider;
+ public static I18n errorAddingOrUpdatingRuleSet;
+ public static I18n errorRollingBackRuleSetAfterUpdateFailed;
+ public static I18n errorReadingRulesAndProperties;
+ public static I18n errorDeregisteringRuleSetBeforeUpdatingIt;
+ public static I18n errorRecreatingRuleSet;
+ public static I18n errorRemovingRuleSet;
+ public static I18n errorRemovingRuleSetUponShutdown;
+ public static I18n unableToFindRuleSet;
+ public static I18n errorExecutingRuleSetWithGlobalsAndFacts;
+ public static I18n unableToBuildRuleSetRegularExpressionPattern;
+
+ public static I18n errorObtainingSessionToRepositoryWorkspace;
+ public static I18n errorWritingProblemsOnRuleSet;
+
+ public static I18n sequencingServiceName;
+ public static I18n unableToChangeExecutionContextWhileRunning;
+ public static I18n unableToStartSequencingServiceWithoutExecutionContext;
+ public static I18n errorWhileSequencingNode;
+ public static I18n errorInRepositoryWhileSequencingNode;
+ public static I18n errorFindingSequencersToRunAgainstNode;
+ public static I18n errorInRepositoryWhileFindingSequencersToRunAgainstNode;
+ public static I18n executionContextHasBeenClosed;
+ public static I18n sequencerTask;
+ public static I18n sequencerSubtask;
+ public static I18n unableToFindPropertyForSequencing;
+ public static I18n sequencingPropertyOnNode;
+ public static I18n writingOutputSequencedFromPropertyOnNodes;
+
+ public static I18n errorReadingPropertiesFromContainerNode;
+ public static I18n requiredPropertyOnNodeWasExpectedToBeStringValue;
+ public static I18n optionalPropertyOnNodeWasExpectedToBeStringValue;
+ public static I18n requiredPropertyOnNodeWasExpectedToBeStringArrayValue;
+ public static I18n optionalPropertyOnNodeWasExpectedToBeStringArrayValue;
+ public static I18n requiredPropertyOnNodeCouldNotBeRead;
+ public static I18n optionalPropertyOnNodeCouldNotBeRead;
+ public static I18n requiredPropertyIsMissingFromNode;
+ public static I18n errorGettingRequiredPropertyFromNode;
+ public static I18n errorGettingOptionalPropertyFromNode;
+ public static I18n errorClosingBinaryStreamForPropertyFromNode;
+ public static I18n requiredNodeDoesNotExistRelativeToNode;
+ public static I18n errorGettingNodeRelativeToNode;
+ public static I18n unknownPropertyValueType;
+
+ public static I18n pathExpressionIsInvalid;
+ public static I18n pathExpressionMayNotBeBlank;
+ public static I18n pathExpressionHasInvalidSelect;
+ public static I18n pathExpressionHasInvalidMatch;
+
+ public static I18n invalidRepositoryNodePath;
+
+}
Property changes on: trunk/dna-repository/src/main/java/org/jboss/dna/repository/RepositoryI18n.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChange.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChange.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChange.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,176 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.observation;
+
+import java.util.Collections;
+import java.util.Set;
+import net.jcip.annotations.Immutable;
+import org.jboss.dna.common.util.HashCode;
+
+/**
+ * A notification of changes to a node.
+ * @author Randall Hauch
+ */
+ at Immutable
+public class NodeChange {
+
+ private final String repositoryWorkspaceName;
+ private final String absolutePath;
+ private final int eventTypes;
+ private final Set<String> modifiedProperties;
+ private final Set<String> removedProperties;
+ private final int hc;
+
+ public NodeChange( String repositoryWorkspaceName, String absolutePath, int eventTypes, Set<String> modifiedProperties, Set<String> removedProperties ) {
+ assert repositoryWorkspaceName != null;
+ assert absolutePath != null;
+ this.repositoryWorkspaceName = repositoryWorkspaceName;
+ this.absolutePath = absolutePath.trim();
+ this.hc = HashCode.compute(this.repositoryWorkspaceName, this.absolutePath);
+ this.eventTypes = eventTypes;
+ if (modifiedProperties == null) modifiedProperties = Collections.emptySet();
+ if (removedProperties == null) removedProperties = Collections.emptySet();
+ this.modifiedProperties = Collections.unmodifiableSet(modifiedProperties);
+ this.removedProperties = Collections.unmodifiableSet(removedProperties);
+ }
+
+ /**
+ * @return absolutePath
+ */
+ public String getAbsolutePath() {
+ return this.absolutePath;
+ }
+
+ /**
+ * @return repositoryWorkspaceName
+ */
+ public String getRepositoryWorkspaceName() {
+ return this.repositoryWorkspaceName;
+ }
+
+ /**
+ * @return modifiedProperties
+ */
+ public Set<String> getModifiedProperties() {
+ return this.modifiedProperties;
+ }
+
+ /**
+ * @return removedProperties
+ */
+ public Set<String> getRemovedProperties() {
+ return this.removedProperties;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int hashCode() {
+ return this.hc;
+ }
+
+ public boolean includesAllEventTypes( int... jcrEventTypes ) {
+ for (int jcrEventType : jcrEventTypes) {
+ if ((this.eventTypes & jcrEventType) == 0) return false;
+ }
+ return true;
+ }
+
+ public boolean includesEventTypes( int... jcrEventTypes ) {
+ for (int jcrEventType : jcrEventTypes) {
+ if ((this.eventTypes & jcrEventType) != 0) return true;
+ }
+ return false;
+ }
+
+ public boolean isSameNode( NodeChange that ) {
+ if (that == this) return true;
+ if (this.hc != that.hc) return false;
+ if (!this.repositoryWorkspaceName.equals(that.repositoryWorkspaceName)) return false;
+ if (!this.absolutePath.equals(that.absolutePath)) return false;
+ return true;
+ }
+
+ /**
+ * Return whether this node change occurs on a node on the supplied path.
+ * @param absolutePath the path
+ * @return true if the node is on the supplied absolute path, or false otherwise
+ * @see #isNotOnPath(String)
+ */
+ public boolean isOnPath( String absolutePath ) {
+ if (absolutePath == null) return false;
+ if (this.getAbsolutePath().startsWith(absolutePath)) return true;
+ return false;
+ }
+
+ /**
+ * Return whether this node change occurs on a node on a different path than that supplied.
+ * @param absolutePath the path
+ * @return true if the node is on a different path, or false if it is on the same path
+ * @see #isOnPath(String)
+ */
+ public boolean isNotOnPath( String absolutePath ) {
+ return !isOnPath(absolutePath);
+ }
+
+ /**
+ * Determine whether this node change includes the setting of new value(s) for the supplied property.
+ * @param property the name of the property
+ * @return true if the named property has a new value on this node, or false otherwise
+ */
+ public boolean isPropertyModified( String property ) {
+ return this.modifiedProperties.contains(property);
+ }
+
+ /**
+ * Determine whether this node change includes the removal of the supplied property.
+ * @param property the name of the property
+ * @return true if the named property was removed from this node, or false otherwise
+ */
+ public boolean isPropertyRemoved( String property ) {
+ return this.removedProperties.contains(property);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals( Object obj ) {
+ if (obj == this) return true;
+ if (obj instanceof NodeChange) {
+ NodeChange that = (NodeChange)obj;
+ if (!this.isSameNode(that)) return false;
+ if (this.eventTypes != that.eventTypes) return false;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return this.repositoryWorkspaceName + "=>" + this.absolutePath;
+ }
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChangeListener.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChangeListener.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChangeListener.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,31 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.observation;
+
+/**
+ * @author Randall Hauch
+ */
+public interface NodeChangeListener {
+
+ void onNodeChanges( NodeChanges changes );
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChanges.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChanges.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/NodeChanges.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,195 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.observation;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.jcr.RepositoryException;
+import javax.jcr.observation.Event;
+import org.jboss.dna.common.i18n.I18n;
+import org.jboss.dna.common.util.Logger;
+import org.jboss.dna.repository.RepositoryI18n;
+
+/**
+ * A utility class that builds node changes from a sequence of events.
+ * @author Randall Hauch
+ */
+public class NodeChanges implements Iterable<NodeChange> {
+
+ public static NodeChanges create( final String repositoryWorkspaceName, Iterable<Event> events ) throws RepositoryException {
+ Map<String, NodeChangeDetails> detailsByNodePath = new HashMap<String, NodeChangeDetails>();
+ // Process each of the events, extracting the node path and property details for each ...
+ for (Event event : events) {
+ final int eventType = event.getType();
+ final String eventPath = event.getPath();
+ if (eventType == Event.PROPERTY_ADDED || eventType == Event.PROPERTY_CHANGED || eventType == Event.PROPERTY_REMOVED) {
+ // Extract the node's path and property name from the even path ...
+ int lastDelim = eventPath.lastIndexOf('/');
+ if (lastDelim < 1 || lastDelim == (eventPath.length() - 1)) {
+ // The last delimiter doesn't exist, is the first character, or is the last character...
+ I18n msg =
+ eventType == Event.PROPERTY_ADDED ? RepositoryI18n.errorFindingPropertyNameInPropertyAddedEvent : eventType == Event.PROPERTY_CHANGED ? RepositoryI18n.errorFindingPropertyNameInPropertyChangedEvent : RepositoryI18n.errorFindingPropertyNameInPropertyRemovedEvent;
+ Logger.getLogger(NodeChanges.class).error(msg, eventPath);
+ continue;
+ }
+ String nodePath = eventPath.substring(0, lastDelim); // excludes the last delim
+ String propertyName = eventPath.substring(lastDelim + 1);
+ // Record the details ...
+ NodeChangeDetails details = detailsByNodePath.get(nodePath);
+ if (details == null) {
+ details = new NodeChangeDetails(nodePath);
+ detailsByNodePath.put(nodePath, details);
+ }
+ switch (eventType) {
+ case Event.PROPERTY_ADDED: {
+ details.addProperty(propertyName);
+ break;
+ }
+ case Event.PROPERTY_CHANGED: {
+ details.changeProperty(propertyName);
+ break;
+ }
+ case Event.PROPERTY_REMOVED: {
+ details.removeProperty(propertyName);
+ break;
+ }
+ }
+ } else if (eventType == Event.NODE_ADDED || eventType == Event.NODE_REMOVED) {
+ // Remove the last delimiter if it appears at the end of the path ...
+ String nodePath = eventPath;
+ if (nodePath.length() > 1 && nodePath.charAt(nodePath.length() - 1) == '/') {
+ nodePath = nodePath.substring(0, nodePath.length() - 1);
+ }
+ // Record the details ...
+ NodeChangeDetails details = detailsByNodePath.get(nodePath);
+ if (details == null) {
+ details = new NodeChangeDetails(nodePath);
+ detailsByNodePath.put(nodePath, details);
+ }
+ details.addEventType(eventType);
+ }
+ }
+
+ // Create the node changes ...
+ List<NodeChange> result = new ArrayList<NodeChange>(detailsByNodePath.size());
+ for (NodeChangeDetails detail : detailsByNodePath.values()) {
+ NodeChange change = new NodeChange(repositoryWorkspaceName, detail.getNodePath(), detail.getEventTypes(), detail.getModifiedProperties(), detail.getRemovedProperties());
+ result.add(change);
+ }
+ return new NodeChanges(result);
+ }
+
+ protected static class NodeChangeDetails {
+
+ private final String nodePath;
+ private final Set<String> modifiedProperties = new HashSet<String>();
+ private final Set<String> removedProperties = new HashSet<String>();
+ private int eventTypes;
+
+ protected NodeChangeDetails( String nodePath ) {
+ this.nodePath = nodePath;
+ }
+
+ public void addEventType( int eventType ) {
+ this.eventTypes |= eventType;
+ }
+
+ public void addProperty( String propertyName ) {
+ this.modifiedProperties.add(propertyName);
+ this.eventTypes |= Event.PROPERTY_ADDED;
+ }
+
+ public void changeProperty( String propertyName ) {
+ this.modifiedProperties.add(propertyName);
+ this.eventTypes |= Event.PROPERTY_CHANGED;
+ }
+
+ public void removeProperty( String propertyName ) {
+ this.removedProperties.add(propertyName);
+ this.eventTypes |= Event.PROPERTY_REMOVED;
+ }
+
+ /**
+ * @return nodeAction
+ */
+ public int getEventTypes() {
+ return this.eventTypes;
+ }
+
+ /**
+ * @return nodePath
+ */
+ public String getNodePath() {
+ return this.nodePath;
+ }
+
+ /**
+ * @return addedProperties
+ */
+ public Set<String> getModifiedProperties() {
+ return this.modifiedProperties;
+ }
+
+ /**
+ * @return removedProperties
+ */
+ public Set<String> getRemovedProperties() {
+ return this.removedProperties;
+ }
+ }
+
+ protected static final Comparator<NodeChange> PRE_ORDER = new Comparator<NodeChange>() {
+
+ public int compare( NodeChange change1, NodeChange change2 ) {
+ return change1.getAbsolutePath().compareTo(change2.getAbsolutePath());
+ }
+ };
+
+ private final List<NodeChange> changesInPreOrder;
+
+ protected NodeChanges( List<NodeChange> changes ) {
+ this.changesInPreOrder = Collections.unmodifiableList(changes);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Iterator<NodeChange> iterator() {
+ return this.changesInPreOrder.iterator();
+ }
+
+ public Iterator<NodeChange> getPreOrder() {
+ return this.changesInPreOrder.iterator();
+ }
+
+ public int size() {
+ return this.changesInPreOrder.size();
+ }
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/ObservationService.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/ObservationService.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/observation/ObservationService.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,722 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.observation;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.UnsupportedRepositoryOperationException;
+import javax.jcr.observation.Event;
+import javax.jcr.observation.EventIterator;
+import javax.jcr.observation.EventListener;
+import javax.jcr.observation.ObservationManager;
+import net.jcip.annotations.GuardedBy;
+import net.jcip.annotations.ThreadSafe;
+import org.jboss.dna.common.util.ArgCheck;
+import org.jboss.dna.common.util.Logger;
+import org.jboss.dna.repository.RepositoryI18n;
+import org.jboss.dna.repository.services.AbstractServiceAdministrator;
+import org.jboss.dna.repository.services.AdministeredService;
+import org.jboss.dna.repository.services.ServiceAdministrator;
+import org.jboss.dna.repository.util.SessionFactory;
+
+/**
+ * @author Randall Hauch
+ */
+public class ObservationService implements AdministeredService {
+
+ /**
+ * Interface to which problems with particular events are logged.
+ * @author Randall Hauch
+ */
+ public static interface ProblemLog {
+
+ void error( String repositoryWorkspaceName, Throwable t );
+ }
+
+ /**
+ * Problem log implementation that records problems in the log.
+ * @author Randall Hauch
+ */
+ public class DefaultProblemLog implements ProblemLog {
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error( String repositoryWorkspaceName, Throwable t ) {
+ getLogger().error(t, RepositoryI18n.errorProcessingEvents, repositoryWorkspaceName);
+ }
+ }
+
+ protected static class NoOpProblemLog implements ProblemLog {
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error( String repositoryWorkspaceName, Throwable t ) {
+ }
+ }
+
+ public static final ProblemLog NO_OP_PROBLEM_LOG = new NoOpProblemLog();
+
+ /**
+ * The administrative component for this service.
+ * @author Randall Hauch
+ */
+ protected class Administrator extends AbstractServiceAdministrator {
+
+ protected Administrator() {
+ super(State.STARTED);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected String serviceName() {
+ return "ObservationService";
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean awaitTermination( long timeout, TimeUnit unit ) {
+ return true;
+ }
+
+ }
+
+ private Logger logger = Logger.getLogger(this.getClass());
+ private ProblemLog problemLog = new DefaultProblemLog();
+ private final Statistics statistics = new Statistics();
+ private final SessionFactory sessionFactory;
+ private final CopyOnWriteArrayList<EventListener> eventListeners = new CopyOnWriteArrayList<EventListener>();
+ private final CopyOnWriteArrayList<NodeChangeListener> nodeChangeListeners = new CopyOnWriteArrayList<NodeChangeListener>();
+ private final Administrator administrator = new Administrator();
+
+ public ObservationService( SessionFactory sessionFactory ) {
+ ArgCheck.isNotNull(sessionFactory, "session factory");
+ this.sessionFactory = sessionFactory;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public ServiceAdministrator getAdministrator() {
+ return this.administrator;
+ }
+
+ /**
+ * @return sessionFactory
+ */
+ public SessionFactory getSessionFactory() {
+ return this.sessionFactory;
+ }
+
+ /**
+ * Get the statistics for this system.
+ * @return the statistics, which are updated as the system is used
+ */
+ public Statistics getStatistics() {
+ return this.statistics;
+ }
+
+ /**
+ * Get the logger for this system
+ * @return the logger
+ */
+ public Logger getLogger() {
+ return this.logger;
+ }
+
+ /**
+ * Set the logger for this system.
+ * @param logger the logger, or null if the standard logging should be used
+ */
+ public void setLogger( Logger logger ) {
+ this.logger = logger != null ? logger : Logger.getLogger(this.getClass());
+ }
+
+ /**
+ * @return problemLog
+ */
+ public ProblemLog getProblemLog() {
+ return this.problemLog;
+ }
+
+ /**
+ * Set the problem log that will be notified of problems handling events. By default, such problems are sent to the log.
+ * @param problemLog the new problem log implementation; if null, then the default problem log is used
+ */
+ public void setProblemLog( ProblemLog problemLog ) {
+ this.problemLog = problemLog != null ? problemLog : new DefaultProblemLog();
+ }
+
+ public boolean addListener( EventListener listener ) {
+ if (listener == null) return false;
+ return this.eventListeners.addIfAbsent(listener);
+ }
+
+ public boolean removeListener( EventListener listener ) {
+ if (listener == null) return false;
+ return this.eventListeners.remove(listener);
+ }
+
+ public boolean addListener( NodeChangeListener listener ) {
+ return this.nodeChangeListeners.addIfAbsent(listener);
+ }
+
+ public boolean removeListener( NodeChangeListener listener ) {
+ if (listener == null) return false;
+ return this.nodeChangeListeners.remove(listener);
+ }
+
+ /**
+ * Monitor the supplied workspace for events of the given type on any node at or under the supplied path.
+ * <p>
+ * Monitoring is accomplished by registering a listener on the workspace, so this monitoring only has access to the
+ * information that visible to the session created by the {@link #getSessionFactory() session factory} for the given
+ * repository and workspace name.
+ * </p>
+ * <p>
+ * The listener returned from this method is not managed by this SequencingService instance. If the listener is no longer
+ * needed, it simply must be {@link ObservationManager#removeEventListener(EventListener) removed} as a listener of the
+ * workspace and garbage collected. If this service is {@link ServiceAdministrator#shutdown() shutdown} while there are still
+ * active listeners, those listeners will disconnect themselves from this service and the workspace with which they're
+ * registered when they attempt to forward the next events.
+ * </p>
+ * <p>
+ * The set of events that are monitored can be filtered by specifying restrictions based on characteristics of the node
+ * associated with the event. In the case of event types {@link Event#NODE_ADDED NODE_ADDED} and
+ * {@link Event#NODE_REMOVED NODE_REMOVED}, the node associated with an event is the node at (or formerly at) the path
+ * returned by {@link Event#getPath() Event.getPath()}. In the case of event types
+ * {@link Event#PROPERTY_ADDED PROPERTY_ADDED}, {@link Event#PROPERTY_REMOVED PROPERTY_REMOVED} and
+ * {@link Event#PROPERTY_CHANGED PROPERTY_CHANGED}, the node associated with an event is the parent node of the property at
+ * (or formerly at) the path returned by <code>Event.getPath</code>:
+ * <ul>
+ * <li> <code>absolutePath</code>, <code>isDeep</code>: Only events whose associated node is at
+ * <code>absolutePath</code> (or within its subtree, if <code>isDeep</code> is <code>true</code>) will be received. It
+ * is permissible to register a listener for a path where no node currently exists. </li>
+ * <li> <code>uuids</code>: Only events whose associated node has one of the UUIDs in this list will be received. If his
+ * parameter is <code>null</code> then no UUID-related restriction is placed on events received. </li>
+ * <li> <code>nodeTypeNames</code>: Only events whose associated node has one of the node types (or a subtype of one of the
+ * node types) in this list will be received. If this parameter is <code>null</code> then no node type-related restriction
+ * is placed on events received. </li>
+ * </ul>
+ * The restrictions are "ANDed" together. In other words, for a particular node to be "listened to" it must meet all the
+ * restrictions.
+ * </p>
+ * <p>
+ * Additionally, if <code>noLocal</code> is <code>true</code>, then events generated by the session through which the
+ * listener was registered are ignored. Otherwise, they are not ignored.
+ * </p>
+ * <p>
+ * The filters of an already-registered {@link WorkspaceListener} can be changed at runtime by changing the attributes and
+ * {@link WorkspaceListener#reregister() registering}.
+ * </p>
+ * @param repositoryWorkspaceName the name to be used with the session factory to obtain a session to the repository and
+ * workspace that is to be monitored
+ * @param absolutePath the absolute path of the node at or below which changes are to be monitored; may be null if all nodes
+ * in the workspace are to be monitored
+ * @param eventTypes the bitmask of the {@link Event} types that are to be monitored
+ * @param isDeep true if events below the node given by the <code>absolutePath</code> or by the <code>uuids</code> are to
+ * be processed, or false if only the events at the node
+ * @param uuids array of UUIDs of nodes that are to be monitored; may be null or empty if the UUIDs are not known
+ * @param nodeTypeNames array of node type names that are to be monitored; may be null or empty if the monitoring has no node
+ * type restrictions
+ * @param noLocal true if the events originating in the supplied workspace are to be ignored, or false if they are also to be
+ * processed.
+ * @return the listener that was created and registered to perform the monitoring
+ * @throws RepositoryException if there is a problem registering the listener
+ */
+ public WorkspaceListener monitor( String repositoryWorkspaceName, String absolutePath, int eventTypes, boolean isDeep, String[] uuids, String[] nodeTypeNames, boolean noLocal )
+ throws RepositoryException {
+ WorkspaceListener listener = new WorkspaceListener(repositoryWorkspaceName, eventTypes, absolutePath, isDeep, uuids, nodeTypeNames, noLocal);
+ listener.register();
+ return listener;
+ }
+
+ /**
+ * Monitor the supplied workspace for {@link WorkspaceListener#DEFAULT_EVENT_TYPES default event types} on any node at or
+ * under the supplied path.
+ * <p>
+ * Monitoring is accomplished by registering a listener on the workspace, so this monitoring only has access to the
+ * information that visible to the session created by the {@link #getSessionFactory() session factory} for the given
+ * repository and workspace name.
+ * </p>
+ * <p>
+ * The listener returned from this method is not managed by this SequencingService instance. If the listener is no longer
+ * needed, it simply must be {@link ObservationManager#removeEventListener(EventListener) removed} as a listener of the
+ * workspace and garbage collected.
+ * </p>
+ * @param repositoryWorkspaceName the name to be used with the session factory to obtain a session to the repository and
+ * workspace that is to be monitored
+ * @param absolutePath the absolute path of the node at or below which changes are to be monitored; may be null if all nodes
+ * in the workspace are to be monitored
+ * @param nodeTypeNames the names of the node types that are to be monitored; may be null or empty if the monitoring has no
+ * node type restrictions
+ * @return the listener that was created and registered to perform the monitoring
+ * @throws RepositoryException if there is a problem registering the listener
+ */
+ public WorkspaceListener monitor( String repositoryWorkspaceName, String absolutePath, String... nodeTypeNames ) throws RepositoryException {
+ return monitor(repositoryWorkspaceName, absolutePath, WorkspaceListener.DEFAULT_EVENT_TYPES, WorkspaceListener.DEFAULT_IS_DEEP, null, nodeTypeNames, WorkspaceListener.DEFAULT_NO_LOCAL);
+ }
+
+ /**
+ * Monitor the supplied workspace for the supplied event types on any node in the workspace.
+ * <p>
+ * Monitoring is accomplished by registering a listener on the workspace, so this monitoring only has access to the
+ * information that visible to the session created by the {@link #getSessionFactory() session factory} for the given
+ * repository and workspace name.
+ * </p>
+ * <p>
+ * The listener returned from this method is not managed by this SequencingService instance. If the listener is no longer
+ * needed, it simply must be {@link ObservationManager#removeEventListener(EventListener) removed} as a listener of the
+ * workspace and garbage collected.
+ * </p>
+ * @param repositoryWorkspaceName the name to be used with the session factory to obtain a session to the repository and
+ * workspace that is to be monitored
+ * @param eventTypes the bitmask of the {@link Event} types that are to be monitored
+ * @param nodeTypeNames the names of the node types that are to be monitored; may be null or empty if the monitoring has no
+ * node type restrictions
+ * @return the listener that was created and registered to perform the monitoring
+ * @throws RepositoryException if there is a problem registering the listener
+ */
+ public WorkspaceListener monitor( String repositoryWorkspaceName, int eventTypes, String... nodeTypeNames ) throws RepositoryException {
+ return monitor(repositoryWorkspaceName, WorkspaceListener.DEFAULT_ABSOLUTE_PATH, eventTypes, WorkspaceListener.DEFAULT_IS_DEEP, null, nodeTypeNames, WorkspaceListener.DEFAULT_NO_LOCAL);
+ }
+
+ /**
+ * From section 2.8.8 of the JSR-170 specification:
+ * <p>
+ * On each persistent change, those listeners that are entitled to receive one or more events will have their onEvent method
+ * called and be passed an EventIterator. The EventIterator will contain the event bundle reflecting the persistent changes
+ * made but excluding those to which that particular listener is not entitled, according to the listeners access permissions
+ * and filters.
+ * </p>
+ * @param events
+ * @param listener
+ */
+ protected void processEvents( EventIterator eventIterator, WorkspaceListener listener ) {
+ if (eventIterator == null) return;
+ List<Event> events = new ArrayList<Event>();
+ // Copy the events ...
+ while (eventIterator.hasNext()) {
+ events.add((Event)eventIterator.next());
+ }
+ if (!getAdministrator().isStarted()) {
+ this.statistics.recordIgnoredEventSet(events.size());
+ return;
+ }
+
+ // Notify the event listeners ...
+ boolean notifiedSomebody = false;
+ List<EventListener> eventListeners = this.eventListeners; // use one consistent snapshot
+ if (!eventListeners.isEmpty()) {
+ DelegatingEventIterator eventIter = new DelegatingEventIterator(events.iterator(), events.size());
+ for (EventListener eventListener : eventListeners) {
+ eventListener.onEvent(eventIter);
+ }
+ notifiedSomebody = true;
+ }
+
+ // Now create the node change events ...
+ List<NodeChangeListener> nodeChangeListeners = this.nodeChangeListeners; // use one consistent snapshot
+ if (!nodeChangeListeners.isEmpty()) {
+ final String repositoryWorkspaceName = listener.getRepositoryWorkspaceName();
+ try {
+ NodeChanges nodeChanges = NodeChanges.create(repositoryWorkspaceName, events);
+
+ // And notify the node change listeners ...
+ int nodeChangeCount = nodeChanges.size();
+ this.statistics.recordNodesChanged(nodeChangeCount);
+ for (NodeChangeListener nodeChangeListener : nodeChangeListeners) {
+ nodeChangeListener.onNodeChanges(nodeChanges);
+ }
+ } catch (Throwable t) {
+ getProblemLog().error(repositoryWorkspaceName, t);
+ }
+ notifiedSomebody = true;
+ }
+
+ if (notifiedSomebody) {
+ this.statistics.recordEventSet(events.size());
+ } else {
+ this.statistics.recordIgnoredEventSet(events.size());
+ }
+ }
+
+ protected class DelegatingEventIterator implements EventIterator {
+
+ private final Iterator<Event> events;
+ private final int size;
+ private int position = 0;
+
+ protected DelegatingEventIterator( Iterator<Event> events, int size ) {
+ this.events = events;
+ this.size = size;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Event nextEvent() {
+ ++position;
+ return events.next();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public long getPosition() {
+ return position;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public long getSize() {
+ return size;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void skip( long skipNum ) {
+ for (int i = 0; i != skipNum; ++i) {
+ next();
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean hasNext() {
+ return events.hasNext();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Object next() {
+ return events.next();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void remove() {
+ // does nothing
+ }
+
+ }
+
+ /**
+ * Implementation of the {@link EventListener JCR EventListener} interface, returned by the sequencing system.
+ * @author Randall Hauch
+ */
+ @ThreadSafe
+ public class WorkspaceListener implements EventListener {
+
+ public static final boolean DEFAULT_IS_DEEP = true;
+ public static final boolean DEFAULT_NO_LOCAL = false;
+ public static final int DEFAULT_EVENT_TYPES = Event.NODE_ADDED | /* Event.NODE_REMOVED| */Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED /* |Event.PROPERTY_REMOVED */;
+ public static final String DEFAULT_ABSOLUTE_PATH = "/";
+
+ private final String repositoryWorkspaceName;
+ private final Set<String> uuids;
+ private final Set<String> nodeTypeNames;
+ private final int eventTypes;
+ private final String absolutePath;
+ private final boolean deep;
+ private final boolean noLocal;
+ @GuardedBy( "this" )
+ private transient Session session;
+
+ protected WorkspaceListener( String repositoryWorkspaceName, int eventTypes, String absPath, boolean isDeep, String[] uuids, String[] nodeTypeNames, boolean noLocal ) {
+ this.repositoryWorkspaceName = repositoryWorkspaceName;
+ this.eventTypes = eventTypes;
+ this.deep = isDeep;
+ this.noLocal = noLocal;
+ this.absolutePath = absPath != null && absPath.trim().length() != 0 ? absPath.trim() : null;
+ // Set the UUIDs ...
+ Set<String> newUuids = new HashSet<String>();
+ if (uuids != null) {
+ for (String uuid : uuids) {
+ if (uuid != null && uuid.trim().length() != 0) newUuids.add(uuid.trim());
+ }
+ }
+ this.uuids = Collections.unmodifiableSet(newUuids);
+ // Set the node type names
+ Set<String> newNodeTypeNames = new HashSet<String>();
+ if (nodeTypeNames != null) {
+ for (String nodeTypeName : nodeTypeNames) {
+ if (nodeTypeName != null && nodeTypeName.trim().length() != 0) newNodeTypeNames.add(nodeTypeName.trim());
+ }
+ }
+ this.nodeTypeNames = Collections.unmodifiableSet(newNodeTypeNames);
+ }
+
+ /**
+ * @return repositoryWorkspaceName
+ */
+ public String getRepositoryWorkspaceName() {
+ return this.repositoryWorkspaceName;
+ }
+
+ /**
+ * @return eventTypes
+ */
+ public int getEventTypes() {
+ return this.eventTypes;
+ }
+
+ /**
+ * @return absolutePath
+ */
+ public String getAbsolutePath() {
+ return this.absolutePath;
+ }
+
+ /**
+ * @return deep
+ */
+ public boolean isDeep() {
+ return this.deep;
+ }
+
+ /**
+ * @return noLocal
+ */
+ public boolean isNoLocal() {
+ return this.noLocal;
+ }
+
+ /**
+ * @return uuids
+ */
+ public Set<String> getUuids() {
+ return this.uuids;
+ }
+
+ /**
+ * @return nodeTypeNames
+ */
+ public Set<String> getNodeTypeNames() {
+ return this.nodeTypeNames;
+ }
+
+ public synchronized boolean isRegistered() {
+ if (this.session != null && getAdministrator().isShutdown()) {
+ // This sequencing system has been shutdown, so unregister this listener
+ try {
+ unregister();
+ } catch (RepositoryException re) {
+ String msg = "Error unregistering workspace listener after sequencing system has been shutdow.";
+ Logger.getLogger(this.getClass()).debug(re, msg);
+ }
+ }
+ return this.session != null;
+ }
+
+ public synchronized WorkspaceListener register() throws UnsupportedRepositoryOperationException, RepositoryException {
+ if (this.session != null) return this;
+ this.session = ObservationService.this.getSessionFactory().createSession(this.repositoryWorkspaceName);
+ String[] uuids = this.uuids.isEmpty() ? null : this.uuids.toArray(new String[this.uuids.size()]);
+ String[] nodeTypeNames = this.nodeTypeNames.isEmpty() ? null : this.nodeTypeNames.toArray(new String[this.nodeTypeNames.size()]);
+ this.session.getWorkspace().getObservationManager().addEventListener(this, eventTypes, absolutePath, deep, uuids, nodeTypeNames, noLocal);
+ return this;
+ }
+
+ public synchronized WorkspaceListener unregister() throws UnsupportedRepositoryOperationException, RepositoryException {
+ if (this.session == null) return this;
+ try {
+ this.session.getWorkspace().getObservationManager().removeEventListener(this);
+ this.session.logout();
+ } finally {
+ this.session = null;
+ }
+ return this;
+ }
+
+ public synchronized WorkspaceListener reregister() throws UnsupportedRepositoryOperationException, RepositoryException {
+ unregister();
+ register();
+ return this;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void onEvent( EventIterator events ) {
+ if (events != null) {
+ if (getAdministrator().isShutdown()) {
+ // This sequencing system has been shutdown, so unregister this listener
+ try {
+ unregister();
+ } catch (RepositoryException re) {
+ String msg = "Error unregistering workspace listener after sequencing system has been shutdow.";
+ Logger.getLogger(this.getClass()).debug(re, msg);
+ }
+ } else {
+ ObservationService.this.processEvents(events, this);
+ }
+ }
+ }
+ }
+
+ /**
+ * The statistics for the system. Each sequencing system has an instance of this class that is updated.
+ * @author Randall Hauch
+ */
+ @ThreadSafe
+ public class Statistics {
+
+ @GuardedBy( "lock" )
+ private long numberOfEventsIgnored;
+ @GuardedBy( "lock" )
+ private long numberOfEventsEnqueued;
+ @GuardedBy( "lock" )
+ private long numberOfEventSetsIgnored;
+ @GuardedBy( "lock" )
+ private long numberOfEventSetsEnqueued;
+ private final AtomicLong numberOfNodeChangesEnqueued = new AtomicLong(0);
+ private final ReadWriteLock lock = new ReentrantReadWriteLock();
+ private final AtomicLong startTime;
+
+ protected Statistics() {
+ startTime = new AtomicLong(System.currentTimeMillis());
+ }
+
+ public Statistics reset() {
+ try {
+ lock.writeLock().lock();
+ this.startTime.set(System.currentTimeMillis());
+ this.numberOfEventsIgnored = 0;
+ this.numberOfEventsEnqueued = 0;
+ this.numberOfEventSetsIgnored = 0;
+ this.numberOfEventSetsEnqueued = 0;
+ this.numberOfNodeChangesEnqueued.set(0);
+ } finally {
+ lock.writeLock().unlock();
+ }
+ return this;
+ }
+
+ /**
+ * @return the system time when the statistics were started
+ */
+ public long getStartTime() {
+ return this.startTime.get();
+ }
+
+ /**
+ * @return the number of node changes that were processed
+ */
+ public long getNumberOfNodeChangesEnqueued() {
+ return this.numberOfNodeChangesEnqueued.get();
+ }
+
+ /**
+ * @return the number of events that were ignored because the system was not running
+ */
+ public long getNumberOfEventsIgnored() {
+ try {
+ lock.readLock().lock();
+ return this.numberOfEventsIgnored;
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ /**
+ * @return the number of events that were enqueued for processing
+ */
+ public long getNumberOfEventsEnqueued() {
+ try {
+ lock.readLock().lock();
+ return this.numberOfEventsEnqueued;
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ /**
+ * @return the number of event sets (transactions) that were enqueued for processing
+ */
+ public long getNumberOfEventSetsEnqueued() {
+ try {
+ lock.readLock().lock();
+ return this.numberOfEventSetsEnqueued;
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ /**
+ * @return the number of event sets (transactions) that were ignored because the system was not running
+ */
+ public long getNumberOfEventSetsIgnored() {
+ try {
+ lock.readLock().lock();
+ return this.numberOfEventSetsIgnored;
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ protected void recordNodesChanged( long changeCount ) {
+ this.numberOfNodeChangesEnqueued.addAndGet(changeCount);
+ }
+
+ protected void recordEventSet( long eventsInSet ) {
+ try {
+ lock.writeLock().lock();
+ this.numberOfEventsEnqueued += eventsInSet;
+ ++this.numberOfEventSetsEnqueued;
+ } finally {
+ lock.writeLock().unlock();
+ }
+ }
+
+ protected void recordIgnoredEventSet( long eventsInSet ) {
+ try {
+ lock.writeLock().lock();
+ this.numberOfEventsIgnored += eventsInSet;
+ this.numberOfEventSetsIgnored += 1;
+ ++this.numberOfEventSetsEnqueued;
+ } finally {
+ lock.writeLock().unlock();
+ }
+ }
+ }
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/InvalidRuleSetException.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/InvalidRuleSetException.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/InvalidRuleSetException.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,60 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.rules;
+
+/**
+ * @author Randall Hauch
+ */
+public class InvalidRuleSetException extends RuntimeException {
+
+ /**
+ *
+ */
+ public InvalidRuleSetException() {
+ }
+
+ /**
+ * @param message
+ */
+ public InvalidRuleSetException( String message ) {
+ super(message);
+
+ }
+
+ /**
+ * @param cause
+ */
+ public InvalidRuleSetException( Throwable cause ) {
+ super(cause);
+
+ }
+
+ /**
+ * @param message
+ * @param cause
+ */
+ public InvalidRuleSetException( String message, Throwable cause ) {
+ super(message, cause);
+
+ }
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleService.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleService.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleService.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,468 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.rules;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringReader;
+import java.rmi.RemoteException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import javax.rules.ConfigurationException;
+import javax.rules.RuleRuntime;
+import javax.rules.RuleServiceProvider;
+import javax.rules.RuleServiceProviderManager;
+import javax.rules.RuleSession;
+import javax.rules.StatelessRuleSession;
+import javax.rules.admin.LocalRuleExecutionSetProvider;
+import javax.rules.admin.RuleAdministrator;
+import javax.rules.admin.RuleExecutionSet;
+import javax.rules.admin.RuleExecutionSetCreateException;
+import javax.rules.admin.RuleExecutionSetDeregistrationException;
+import net.jcip.annotations.GuardedBy;
+import net.jcip.annotations.ThreadSafe;
+import org.jboss.dna.common.SystemFailureException;
+import org.jboss.dna.common.component.ClassLoaderFactory;
+import org.jboss.dna.common.component.StandardClassLoaderFactory;
+import org.jboss.dna.common.util.ArgCheck;
+import org.jboss.dna.common.util.Logger;
+import org.jboss.dna.common.util.StringUtil;
+import org.jboss.dna.repository.RepositoryI18n;
+import org.jboss.dna.repository.services.AbstractServiceAdministrator;
+import org.jboss.dna.repository.services.AdministeredService;
+import org.jboss.dna.repository.services.ServiceAdministrator;
+
+/**
+ * A rule service that is capable of executing rule sets using one or more JSR-94 rule engines. Sets of rules are
+ * {@link #addRuleSet(RuleSet) added}, {@link #updateRuleSet(RuleSet) updated}, and {@link #removeRuleSet(String) removed}
+ * (usually by some other component), and then these named rule sets can be {@link #executeRules(String, Map, Object...) run} with
+ * inputs and facts to obtain output.
+ * <p>
+ * This service is thread safe. While multiple rule sets can be safely {@link #executeRules(String, Map, Object...) executed} at
+ * the same time, all executions will be properly synchronized with methods to {@link #addRuleSet(RuleSet) add},
+ * {@link #updateRuleSet(RuleSet) update}, and {@link #removeRuleSet(String) remove} rule sets.
+ * </p>
+ * @author Randall Hauch
+ */
+ at ThreadSafe
+public class RuleService implements AdministeredService {
+
+ protected static final ClassLoaderFactory DEFAULT_CLASSLOADER_FACTORY = new StandardClassLoaderFactory(RuleService.class.getClassLoader());
+
+ /**
+ * The administrative component for this service.
+ * @author Randall Hauch
+ */
+ protected class Administrator extends AbstractServiceAdministrator {
+
+ protected Administrator() {
+ super(State.PAUSED);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected String serviceName() {
+ return "RuleService";
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected void doShutdown( State fromState ) {
+ super.doShutdown(fromState);
+ // Remove all rule sets ...
+ removeAllRuleSets();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean awaitTermination( long timeout, TimeUnit unit ) throws InterruptedException {
+ return doAwaitTermination(timeout, unit);
+ }
+
+ }
+
+ private Logger logger;
+ private ClassLoaderFactory classLoaderFactory = DEFAULT_CLASSLOADER_FACTORY;
+ private final Administrator administrator = new Administrator();
+ private final ReadWriteLock lock = new ReentrantReadWriteLock();
+ @GuardedBy( "lock" )
+ private final Map<String, RuleSet> ruleSets = new HashMap<String, RuleSet>();
+ private final CountDownLatch shutdownLatch = new CountDownLatch(1);
+
+ /**
+ * Create a new rule service, configured with no rule sets. Upon construction, the system is
+ * {@link ServiceAdministrator#isPaused() paused} and must be configured and then {@link ServiceAdministrator#start() started}.
+ */
+ public RuleService() {
+ this.logger = Logger.getLogger(this.getClass());
+ }
+
+ /**
+ * Return the administrative component for this service.
+ * @return the administrative component; never null
+ */
+ public ServiceAdministrator getAdministrator() {
+ return this.administrator;
+ }
+
+ /**
+ * Get the class loader factory that should be used to load sequencers. By default, this service uses a factory that will
+ * return either the {@link Thread#getContextClassLoader() current thread's context class loader} (if not null) or the class
+ * loader that loaded this class.
+ * @return the class loader factory; never null
+ * @see #setClassLoaderFactory(ClassLoaderFactory)
+ */
+ public ClassLoaderFactory getClassLoaderFactory() {
+ return this.classLoaderFactory;
+ }
+
+ /**
+ * Set the Maven Repository that should be used to load the sequencer classes. By default, this service uses a class loader
+ * factory that will return either the {@link Thread#getContextClassLoader() current thread's context class loader} (if not
+ * null) or the class loader that loaded this class.
+ * @param classLoaderFactory the class loader factory reference, or null if the default class loader factory should be used.
+ * @see #getClassLoaderFactory()
+ */
+ public void setClassLoaderFactory( ClassLoaderFactory classLoaderFactory ) {
+ this.classLoaderFactory = classLoaderFactory != null ? classLoaderFactory : DEFAULT_CLASSLOADER_FACTORY;
+ }
+
+ /**
+ * Obtain the rule sets that are currently available in this service.
+ * @return an unmodifiable copy of the rule sets; never null, but possibly empty ...
+ */
+ public Collection<RuleSet> getRuleSets() {
+ List<RuleSet> results = new ArrayList<RuleSet>();
+ try {
+ this.lock.readLock().lock();
+ // Make a copy of the rule sets ...
+ if (ruleSets.size() != 0) results.addAll(this.ruleSets.values());
+ } finally {
+ this.lock.readLock().unlock();
+ }
+ return Collections.unmodifiableList(results);
+ }
+
+ /**
+ * Add a rule set, or update any existing one that represents the {@link RuleSet#equals(Object) same rule set}
+ * @param ruleSet the new rule set
+ * @return true if the rule set was added, or false if the rule set was not added (because it wasn't necessary)
+ * @throws IllegalArgumentException if <code>ruleSet</code> is null
+ * @throws InvalidRuleSetException if the supplied rule set is invalid, incomplete, incorrectly defined, or uses a JSR-94
+ * service provider that cannot be found
+ * @see #updateRuleSet(RuleSet)
+ * @see #removeRuleSet(String)
+ */
+ public boolean addRuleSet( RuleSet ruleSet ) {
+ ArgCheck.isNotNull(ruleSet, "rule set");
+ final String providerUri = ruleSet.getProviderUri();
+ final String ruleSetName = ruleSet.getName();
+ final String rules = ruleSet.getRules();
+ final Map<?, ?> properties = ruleSet.getExecutionSetProperties();
+ final Reader ruleReader = new StringReader(rules);
+ boolean updatedRuleSets = false;
+ try {
+ this.lock.writeLock().lock();
+
+ // Make sure the rule service provider is available ...
+ RuleServiceProvider ruleServiceProvider = findRuleServiceProvider(ruleSet);
+ assert ruleServiceProvider != null;
+
+ // Now register a new execution set ...
+ RuleAdministrator ruleAdmin = ruleServiceProvider.getRuleAdministrator();
+ if (ruleAdmin == null) {
+ throw new InvalidRuleSetException(RepositoryI18n.unableToObtainJsr94RuleAdministrator.text(providerUri, ruleSet.getComponentClassname(), ruleSetName));
+ }
+
+ // Is there is an existing rule set and, if so, whether it has changed ...
+ RuleSet existing = this.ruleSets.get(ruleSetName);
+
+ // Create the rule execution set (do this before deregistering, in case there is a problem)...
+ LocalRuleExecutionSetProvider ruleExecutionSetProvider = ruleAdmin.getLocalRuleExecutionSetProvider(null);
+ RuleExecutionSet executionSet = ruleExecutionSetProvider.createRuleExecutionSet(ruleReader, properties);
+
+ // We should add the execiting rule set if there wasn't one or if the rule set has changed ...
+ boolean shouldAdd = existing == null || ruleSet.hasChanged(existing);
+ if (existing != null && shouldAdd) {
+ // There is an existing execution set and it needs to be updated, so deregister it ...
+ ruleServiceProvider = deregister(ruleSet);
+ }
+ if (shouldAdd) {
+ boolean rollback = false;
+ try {
+ // Now register the new execution set and update the rule set managed by this service ...
+ ruleAdmin.registerRuleExecutionSet(ruleSetName, executionSet, null);
+ this.ruleSets.remove(ruleSet.getName());
+ this.ruleSets.put(ruleSet.getName(), ruleSet);
+ updatedRuleSets = true;
+ } catch (Throwable t) {
+ rollback = true;
+ throw new InvalidRuleSetException(RepositoryI18n.errorAddingOrUpdatingRuleSet.text(ruleSet.getName()), t);
+ } finally {
+ if (rollback) {
+ try {
+ // There was a problem, so re-register the original existing rule set ...
+ if (existing != null) {
+ final String oldRules = existing.getRules();
+ final Map<?, ?> oldProperties = existing.getExecutionSetProperties();
+ final Reader oldRuleReader = new StringReader(oldRules);
+ ruleServiceProvider = findRuleServiceProvider(existing);
+ assert ruleServiceProvider != null;
+ executionSet = ruleExecutionSetProvider.createRuleExecutionSet(oldRuleReader, oldProperties);
+ ruleAdmin.registerRuleExecutionSet(ruleSetName, executionSet, null);
+ this.ruleSets.remove(ruleSetName);
+ this.ruleSets.put(ruleSetName, existing);
+ }
+ } catch (Throwable rollbackError) {
+ // There was a problem rolling back to the existing rule set, and we're going to throw the
+ // exception associated with the updated/new rule set, so just log this problem
+ this.logger.error(rollbackError, RepositoryI18n.errorRollingBackRuleSetAfterUpdateFailed, ruleSetName);
+ }
+ }
+ }
+ }
+ } catch (InvalidRuleSetException e) {
+ throw e;
+ } catch (ConfigurationException t) {
+ throw new InvalidRuleSetException(RepositoryI18n.unableToObtainJsr94RuleAdministrator.text(providerUri, ruleSet.getComponentClassname(), ruleSetName));
+ } catch (RemoteException t) {
+ throw new InvalidRuleSetException(RepositoryI18n.errorUsingJsr94RuleAdministrator.text(providerUri, ruleSet.getComponentClassname(), ruleSetName));
+ } catch (IOException t) {
+ throw new InvalidRuleSetException(RepositoryI18n.errorReadingRulesAndProperties.text(ruleSetName));
+ } catch (RuleExecutionSetDeregistrationException t) {
+ throw new InvalidRuleSetException(RepositoryI18n.errorDeregisteringRuleSetBeforeUpdatingIt.text(ruleSetName));
+ } catch (RuleExecutionSetCreateException t) {
+ throw new InvalidRuleSetException(RepositoryI18n.errorRecreatingRuleSet.text(ruleSetName));
+ } finally {
+ this.lock.writeLock().unlock();
+ }
+ return updatedRuleSets;
+ }
+
+ /**
+ * Update the configuration for a sequencer, or add it if there is no {@link RuleSet#equals(Object) matching configuration}.
+ * @param ruleSet the rule set to be updated
+ * @return true if the rule set was updated, or false if the rule set was not updated (because it wasn't necessary)
+ * @throws InvalidRuleSetException if the supplied rule set is invalid, incomplete, incorrectly defined, or uses a JSR-94
+ * service provider that cannot be found
+ * @see #addRuleSet(RuleSet)
+ * @see #removeRuleSet(String)
+ */
+ public boolean updateRuleSet( RuleSet ruleSet ) {
+ return addRuleSet(ruleSet);
+ }
+
+ /**
+ * Remove a rule set.
+ * @param ruleSetName the name of the rule set to be removed
+ * @return true if the rule set was removed, or if it was not an existing rule set
+ * @throws IllegalArgumentException if <code>ruleSetName</code> is null or empty
+ * @throws SystemFailureException if the rule set was found but there was a problem removing it
+ * @see #addRuleSet(RuleSet)
+ * @see #updateRuleSet(RuleSet)
+ */
+ public boolean removeRuleSet( String ruleSetName ) {
+ ArgCheck.isNotEmpty(ruleSetName, "rule set");
+ try {
+ this.lock.writeLock().lock();
+ RuleSet ruleSet = this.ruleSets.remove(ruleSetName);
+ if (ruleSet != null) {
+ try {
+ deregister(ruleSet);
+ } catch (Throwable t) {
+ // There was a problem deregistering the rule set, so put it back ...
+ this.ruleSets.put(ruleSetName, ruleSet);
+ }
+ return true;
+ }
+ } catch (Throwable t) {
+ throw new SystemFailureException(RepositoryI18n.errorRemovingRuleSet.text(ruleSetName), t);
+ } finally {
+ this.lock.writeLock().unlock();
+ }
+ return false;
+ }
+
+ /**
+ * Get the logger for this system
+ * @return the logger
+ */
+ public Logger getLogger() {
+ return this.logger;
+ }
+
+ /**
+ * Set the logger for this system.
+ * @param logger the logger, or null if the standard logging should be used
+ */
+ public void setLogger( Logger logger ) {
+ this.logger = logger != null ? logger : Logger.getLogger(this.getClass());
+ }
+
+ /**
+ * Execute the set of rules defined by the supplied rule set name. This method is safe to be concurrently called by multiple
+ * threads, and is properly synchronized with the methods to {@link #addRuleSet(RuleSet) add},
+ * {@link #updateRuleSet(RuleSet) update}, and {@link #removeRuleSet(String) remove} rule sets.
+ * @param ruleSetName the {@link RuleSet#getName() name} of the {@link RuleSet} that should be used
+ * @param globals the global variables
+ * @param facts the facts
+ * @return the results of executing the rule set
+ * @throws IllegalArgumentException if the rule set name is null, empty or blank, or if there is no rule set with the given
+ * name
+ * @throws SystemFailureException if there is no JSR-94 rule service provider with the
+ * {@link RuleSet#getProviderUri() RuleSet's provider URI}.
+ */
+ public List<?> executeRules( String ruleSetName, Map<String, Object> globals, Object... facts ) {
+ ArgCheck.isNotEmpty(ruleSetName, "rule set name");
+ List<?> result = null;
+ List<?> factList = Arrays.asList(facts);
+ try {
+ this.lock.readLock().lock();
+
+ // Find the rule set ...
+ RuleSet ruleSet = this.ruleSets.get(ruleSetName);
+ if (ruleSet == null) {
+ throw new IllegalArgumentException(RepositoryI18n.unableToFindRuleSet.text(ruleSetName));
+ }
+
+ // Look up the provider ...
+ RuleServiceProvider ruleServiceProvider = findRuleServiceProvider(ruleSet);
+ assert ruleServiceProvider != null;
+
+ // Create the rule session ...
+ RuleRuntime ruleRuntime = ruleServiceProvider.getRuleRuntime();
+ String executionSetName = ruleSet.getRuleSetUri();
+ RuleSession session = ruleRuntime.createRuleSession(executionSetName, globals, RuleRuntime.STATELESS_SESSION_TYPE);
+ try {
+ StatelessRuleSession statelessSession = (StatelessRuleSession)session;
+ result = statelessSession.executeRules(factList);
+ } finally {
+ session.release();
+ }
+ if (this.logger.isTraceEnabled()) {
+ String msg = "Executed rule set '{1}' with globals {2} and facts {3} resulting in {4}";
+ this.logger.trace(msg, ruleSetName, StringUtil.readableString(globals), StringUtil.readableString(facts), StringUtil.readableString(result));
+ }
+ } catch (Throwable t) {
+ throw new SystemFailureException(RepositoryI18n.errorExecutingRuleSetWithGlobalsAndFacts.text(ruleSetName, StringUtil.readableString(globals), StringUtil.readableString(facts)), t);
+ } finally {
+ this.lock.readLock().unlock();
+ }
+ return result;
+ }
+
+ protected void removeAllRuleSets() {
+ try {
+ lock.writeLock().lock();
+ for (RuleSet ruleSet : ruleSets.values()) {
+ try {
+ deregister(ruleSet);
+ } catch (Throwable t) {
+ logger.error(t, RepositoryI18n.errorRemovingRuleSetUponShutdown, ruleSet.getName());
+ }
+ }
+ } finally {
+ lock.writeLock().unlock();
+ }
+ this.shutdownLatch.countDown();
+ }
+
+ protected boolean doAwaitTermination( long timeout, TimeUnit unit ) throws InterruptedException {
+ return this.shutdownLatch.await(timeout, unit);
+ }
+
+ /**
+ * Finds the JSR-94 service provider instance and returns it. If it could not be found, this method attempts to load it.
+ * @param ruleSet the rule set for which the service provider is to be found; may not be null
+ * @return the rule service provider; never null
+ * @throws ConfigurationException if there is a problem loading the service provider
+ * @throws InvalidRuleSetException if the service provider could not be found
+ */
+ private RuleServiceProvider findRuleServiceProvider( RuleSet ruleSet ) throws ConfigurationException {
+ assert ruleSet != null;
+ String providerUri = ruleSet.getProviderUri();
+ RuleServiceProvider ruleServiceProvider = null;
+ try {
+ // If the provider could not be found, then a ConfigurationException will be thrown ...
+ ruleServiceProvider = RuleServiceProviderManager.getRuleServiceProvider(providerUri);
+ } catch (ConfigurationException e) {
+ try {
+ // Use JSR-94 to load the RuleServiceProvider instance ...
+ ClassLoader loader = this.classLoaderFactory.getClassLoader(ruleSet.getComponentClasspathArray());
+ // Don't call ClassLoader.loadClass(String), as this doesn't initialize the class!!
+ Class.forName(ruleSet.getComponentClassname(), true, loader);
+ ruleServiceProvider = RuleServiceProviderManager.getRuleServiceProvider(providerUri);
+ this.logger.debug("Loaded the rule service provider {0} ({1})", providerUri, ruleSet.getComponentClassname());
+ } catch (ConfigurationException ce) {
+ throw ce;
+ } catch (Throwable t) {
+ throw new InvalidRuleSetException(RepositoryI18n.unableToObtainJsr94ServiceProvider.text(providerUri, ruleSet.getComponentClassname()), t);
+ }
+ }
+ if (ruleServiceProvider == null) {
+ throw new InvalidRuleSetException(RepositoryI18n.unableToObtainJsr94ServiceProvider.text(providerUri, ruleSet.getComponentClassname()));
+ }
+ return ruleServiceProvider;
+ }
+
+ /**
+ * Deregister the supplied rule set, if it could be found. This method does nothing if any of the service provider components
+ * could not be found.
+ * @param ruleSet the rule set to be deregistered; may not be null
+ * @return the service provider reference, or null if the service provider could not be found ...
+ * @throws ConfigurationException
+ * @throws RuleExecutionSetDeregistrationException
+ * @throws RemoteException
+ */
+ private RuleServiceProvider deregister( RuleSet ruleSet ) throws ConfigurationException, RuleExecutionSetDeregistrationException, RemoteException {
+ assert ruleSet != null;
+ // Look up the provider ...
+ String providerUri = ruleSet.getProviderUri();
+ assert providerUri != null;
+
+ // Look for the provider ...
+ RuleServiceProvider ruleServiceProvider = RuleServiceProviderManager.getRuleServiceProvider(providerUri);
+ if (ruleServiceProvider != null) {
+ // Deregister the rule set ...
+ RuleAdministrator ruleAdmin = ruleServiceProvider.getRuleAdministrator();
+ if (ruleAdmin != null) {
+ ruleAdmin.deregisterRuleExecutionSet(ruleSet.getRuleSetUri(), null);
+ }
+ }
+ return ruleServiceProvider;
+ }
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleSet.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleSet.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleSet.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,152 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.rules;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import javax.rules.RuleServiceProvider;
+import javax.rules.admin.RuleExecutionSet;
+import javax.rules.admin.RuleExecutionSetProvider;
+import net.jcip.annotations.Immutable;
+import org.jboss.dna.common.component.ClassLoaderFactory;
+import org.jboss.dna.common.component.ComponentConfig;
+import org.jboss.dna.common.util.ArgCheck;
+
+/**
+ * A description of a set of rules compatible with a JSR-94 rule engine.
+ * @author Randall Hauch
+ */
+ at Immutable
+public class RuleSet extends ComponentConfig implements Cloneable {
+
+ private final String providerUri;
+ private final String ruleSetUri;
+ private final String rules;
+ private final Map<String, Object> properties;
+
+ /**
+ * Create a JSR-94 rule set definition.
+ * @param name the name of the rule set, which is considered the unique identifier
+ * @param description the description
+ * @param classname the name of the Java class used for the component
+ * @param classpath the optional classpath (defined in a way compatible with a {@link ClassLoaderFactory}
+ * @param providerUri the URI of the JSR-94 {@link RuleServiceProvider} implementation to use
+ * @param ruleSetUri the URI of the JSR-94 {@link RuleExecutionSet} represented by this object; if null, the name is used
+ * @param rules the string containing the rules in a provider-specific language
+ * @param properties the provider-specific properties, whose values should be strings or byte arrays (the latter if the
+ * provider expects an {@link Reader} with the value)
+ * @throws IllegalArgumentException if any of the name, classname, provider URI, or rules parameters are null, empty or blank,
+ * or if the classname is not a valid Java classname
+ */
+ public RuleSet( String name, String description, String classname, String[] classpath, String providerUri, String ruleSetUri, String rules, Map<String, Object> properties ) {
+ super(name, description, System.currentTimeMillis(), classname, classpath);
+ if (ruleSetUri == null) ruleSetUri = name.trim();
+ ArgCheck.isNotEmpty(ruleSetUri, "rule set URI");
+ ArgCheck.isNotEmpty(providerUri, "provider URI");
+ ArgCheck.isNotEmpty(rules, "rules");
+ this.providerUri = providerUri;
+ this.ruleSetUri = ruleSetUri;
+ this.rules = rules;
+ if (properties == null) properties = Collections.emptyMap();
+ this.properties = Collections.unmodifiableMap(properties);
+ }
+
+ /**
+ * Get the URI of the JSR-94 {@link RuleServiceProvider} implementation that should be used.
+ * @return the URI of the JSR-94 implementation; never null, empty or blank
+ */
+ public String getProviderUri() {
+ return this.providerUri;
+ }
+
+ /**
+ * Get the URI of this rule set. The value must be valid as defined by JSR-94 {@link RuleExecutionSet}.
+ * @return the rule set's URI; never null, empty or blank
+ */
+ public String getRuleSetUri() {
+ return this.ruleSetUri;
+ }
+
+ /**
+ * Get the rules defined in terms of the language reqired by the {@link #getProviderUri() provider}.
+ * @return the rules for this rule set
+ */
+ public String getRules() {
+ return this.rules;
+ }
+
+ /**
+ * Get this rule set's properties as an unmodifiable map. Note that the values of these properties are either strings if the
+ * value is to be {@link #getExecutionSetProperties() passed} literally, or a byte array if the value is to be
+ * {@link #getExecutionSetProperties() passed} as an InputStream.
+ * @return the unmodifiable properties; never null but possible empty
+ */
+ public Map<String, Object> getProperties() {
+ return this.properties;
+ }
+
+ /**
+ * Get the properties for this rule set that can be passed to an {@link RuleExecutionSetProvider}'s
+ * {@link RuleExecutionSetProvider#createRuleExecutionSet(String, Map) createRuleExecutionSet} method.
+ * <p>
+ * This method converts any byte array value in the {@link #getProperties() properties} into an {@link Reader}. Since
+ * {@link ByteArrayInputStream} is used, there is no need to close these stream.
+ * </p>
+ * @return the properties; never null but possible empty
+ */
+ public Map<Object, Object> getExecutionSetProperties() {
+ Map<Object, Object> props = new HashMap<Object, Object>();
+ for (Map.Entry<String, Object> entry : this.properties.entrySet()) {
+ String key = entry.getKey();
+ Object value = entry.getValue();
+ if (value instanceof byte[]) {
+ value = new InputStreamReader(new ByteArrayInputStream((byte[])value));
+ }
+ props.put(key, value);
+ }
+ return props;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean hasChanged( ComponentConfig obj ) {
+ if (super.hasChanged(obj)) return true;
+ RuleSet that = (RuleSet)obj;
+ if (!this.providerUri.equals(that.providerUri)) return true;
+ if (!this.ruleSetUri.equals(that.ruleSetUri)) return true;
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public RuleSet clone() {
+ return new RuleSet(this.getName(), this.getDescription(), this.getComponentClassname(), this.getComponentClasspathArray(), this.providerUri, this.ruleSetUri, this.rules, this.properties);
+ }
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleSetRepositoryMonitor.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleSetRepositoryMonitor.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/rules/RuleSetRepositoryMonitor.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,257 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.rules;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+import javax.jcr.Node;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import net.jcip.annotations.ThreadSafe;
+import org.jboss.dna.common.collection.Problems;
+import org.jboss.dna.common.util.ArgCheck;
+import org.jboss.dna.common.util.Logger;
+import org.jboss.dna.repository.RepositoryI18n;
+import org.jboss.dna.repository.observation.NodeChange;
+import org.jboss.dna.repository.observation.NodeChangeListener;
+import org.jboss.dna.repository.observation.NodeChanges;
+import org.jboss.dna.repository.observation.ObservationService;
+import org.jboss.dna.repository.util.ExecutionContext;
+import org.jboss.dna.repository.util.JcrTools;
+
+/**
+ * A component that can listen to a JCR repository and keep the {@link RuleSet} instances of a {@link RuleService} synchronized
+ * with that repository.
+ * <p>
+ * This class is a {@link NodeChangeListener} that can {@link ObservationService#addListener(NodeChangeListener) subscribe} to
+ * changes in one or more JCR repositories being monitored by an {@link ObservationService}. As changes under the rule sets
+ * branch are discovered, they are processed asynchronously. This ensure that the processing of the repository contents does not
+ * block the other listeners of the {@link ObservationService}.
+ * </p>
+ * @author Randall Hauch
+ */
+ at ThreadSafe
+public class RuleSetRepositoryMonitor implements NodeChangeListener {
+
+ public static final String DEFAULT_JCR_ABSOLUTE_PATH = "/dna:system/dna:ruleSets/";
+
+ protected static final String JCR_PATH_DELIM = "/";
+
+ private final ExecutionContext executionContext;
+ private final RuleService ruleService;
+ private final String jcrAbsolutePath;
+ private final Pattern ruleSetNamePattern;
+ private final ExecutorService executorService;
+ private Logger logger;
+
+ /**
+ * Create an instance that can listen to the {@link RuleSet} definitions stored in a JCR repository and ensure that the
+ * {@link RuleSet} instances of a {@link RuleService} reflect the definitions in the repository.
+ * @param ruleService the rule service that should be kept in sync with the JCR repository.
+ * @param jcrAbsolutePath the absolute path to the branch where the rule sets are defined; if null or empty, the
+ * {@link #DEFAULT_JCR_ABSOLUTE_PATH default path} is used
+ * @param executionContext the context in which this monitor is to execute
+ * @throws IllegalArgumentException if the rule service or execution context is null, or if the supplied
+ * <code>jcrAbsolutePath</code> is invalid
+ */
+ public RuleSetRepositoryMonitor( RuleService ruleService, String jcrAbsolutePath, ExecutionContext executionContext ) {
+ ArgCheck.isNotNull(ruleService, "rule service");
+ ArgCheck.isNotNull(executionContext, "execution context");
+ this.ruleService = ruleService;
+ this.executionContext = executionContext;
+ this.executorService = Executors.newSingleThreadExecutor();
+ this.logger = Logger.getLogger(this.getClass());
+ if (jcrAbsolutePath != null) jcrAbsolutePath = jcrAbsolutePath.trim();
+ this.jcrAbsolutePath = jcrAbsolutePath != null && jcrAbsolutePath.length() != 0 ? jcrAbsolutePath : DEFAULT_JCR_ABSOLUTE_PATH;
+ try {
+ // Create the pattern to extract the rule set name from the absolute path ...
+ String leadingPath = this.jcrAbsolutePath;
+ if (!leadingPath.endsWith(JCR_PATH_DELIM)) leadingPath = leadingPath + JCR_PATH_DELIM;
+ this.ruleSetNamePattern = Pattern.compile(leadingPath + "([^/]+)/?.*");
+ } catch (PatternSyntaxException e) {
+ throw new IllegalArgumentException(RepositoryI18n.unableToBuildRuleSetRegularExpressionPattern.text(e.getPattern(), jcrAbsolutePath, e.getDescription()));
+ }
+ }
+
+ /**
+ * @return ruleService
+ */
+ public RuleService getRuleService() {
+ return this.ruleService;
+ }
+
+ /**
+ * @return jcrAbsolutePath
+ */
+ public String getAbsolutePathToRuleSets() {
+ return this.jcrAbsolutePath;
+ }
+
+ /**
+ * @return logger
+ */
+ public Logger getLogger() {
+ return this.logger;
+ }
+
+ /**
+ * @param logger Sets logger to the specified value.
+ */
+ public void setLogger( Logger logger ) {
+ this.logger = logger;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void onNodeChanges( NodeChanges changes ) {
+ final Map<String, Set<String>> ruleSetNamesByWorkspaceName = new HashMap<String, Set<String>>();
+ for (NodeChange nodeChange : changes) {
+ if (nodeChange.isNotOnPath(this.jcrAbsolutePath)) continue;
+ // Use a regular expression on the absolute path to get the name of the rule set that is affected ...
+ Matcher matcher = this.ruleSetNamePattern.matcher(nodeChange.getAbsolutePath());
+ if (!matcher.matches()) continue;
+ String ruleSetName = matcher.group(1);
+ // Record the repository name ...
+ String workspaceName = nodeChange.getRepositoryWorkspaceName();
+ Set<String> ruleSetNames = ruleSetNamesByWorkspaceName.get(workspaceName);
+ if (ruleSetNames == null) {
+ ruleSetNames = new HashSet<String>();
+ ruleSetNamesByWorkspaceName.put(workspaceName, ruleSetNames);
+ }
+ // Record the rule set name ...
+ ruleSetNames.add(ruleSetName);
+
+ }
+ if (ruleSetNamesByWorkspaceName.isEmpty()) return;
+ // Otherwise there are changes, so submit the names to the executor service ...
+ this.executorService.execute(new Runnable() {
+
+ public void run() {
+ processRuleSets(ruleSetNamesByWorkspaceName);
+ }
+ });
+ }
+
+ /**
+ * Process the rule sets given by the supplied names, keyed by the repository workspace name.
+ * @param ruleSetNamesByWorkspaceName the set of rule set names keyed by the repository workspace name
+ */
+ protected void processRuleSets( Map<String, Set<String>> ruleSetNamesByWorkspaceName ) {
+ final JcrTools tools = this.executionContext.getTools();
+ final String relPathToRuleSets = getAbsolutePathToRuleSets().substring(1);
+ for (Map.Entry<String, Set<String>> entry : ruleSetNamesByWorkspaceName.entrySet()) {
+ String workspaceName = entry.getKey();
+ Session session = null;
+ try {
+ session = this.executionContext.getSessionFactory().createSession(workspaceName);
+ // Look up the node that represents the parent of the rule set nodes ...
+ Node ruleSetsNode = session.getRootNode().getNode(relPathToRuleSets);
+
+ for (String ruleSetName : entry.getValue()) {
+ // Look up the node that represents the rule set...
+ if (ruleSetsNode.hasNode(ruleSetName)) {
+ // We don't handle multiple siblings with the same name, so this should grab the first one ...
+ Node ruleSetNode = ruleSetsNode.getNode(ruleSetName);
+ RuleSet ruleSet = buildRuleSet(ruleSetName, ruleSetNode, tools);
+ if (ruleSet != null) {
+ // Only do something if the RuleSet was instantiated ...
+ getRuleService().addRuleSet(ruleSet);
+ }
+ } else {
+ // The node doesn't exist, so remove the rule set ...
+ getRuleService().removeRuleSet(ruleSetName);
+ }
+ }
+ } catch (RepositoryException e) {
+ getLogger().error(e, RepositoryI18n.errorObtainingSessionToRepositoryWorkspace, workspaceName);
+ } finally {
+ if (session != null) session.logout();
+ }
+ }
+ }
+
+ /**
+ * Create a rule set from the supplied node. This is called whenever a branch of the repository is changed.
+ * <p>
+ * This implementation expects a node of type 'dna:ruleSet' and the following properties (expressed as XPath statements
+ * relative to the supplied node):
+ * <ul>
+ * <li>The {@link RuleSet#getDescription() description} is obtained from the "<code>./@jcr:description</code>" string
+ * property. This property is optional.</li>
+ * <li>The {@link RuleSet#getComponentClassname() classname} is obtained from the "<code>./@dna:classname</code>" string
+ * property. This property is required.</li>
+ * <li>The {@link RuleSet#getComponentClasspath() classpath} is obtained from the "<code>./@dna:classpath</code>" string
+ * property. This property is optional, and if abscent then the classpath will be assumed from the current context.</li>
+ * <li>The {@link RuleSet#getProviderUri() provider URI} is obtained from the "<code>./@dna:serviceProviderUri</code>"
+ * string property, and corresponds to the URI of the JSR-94 rules engine service provider. This property is required.</li>
+ * <li>The {@link RuleSet#getRuleSetUri() rule set URI} is obtained from the "<code>./@dna:ruleSetUri</code>" string
+ * property. This property is optional and defaults to the node name (e.g., "<code>./@jcr:name</code>").</li>
+ * <li>The {@link RuleSet#getRules() definition of the rules} is obtained from the "<code>./@dna:rules</code>" string
+ * property. This property is required and must be in a form suitable for the JSR-94 rules engine.</li>
+ * <li>The {@link RuleSet#getProperties() properties} are obtained from the "<code>./dna:properties[contains(@jcr:mixinTypes,'dna:propertyContainer')]/*[@jcr:nodeType='dna:property']</code>"
+ * property nodes, where the name of the property is extracted from the property node's "<code>./@jcr:name</code>" string
+ * property and the value of the property is extracted from the property node's "<code>./@dna:propertyValue</code>" string
+ * property. Rule set properties are optional.</li>
+ * </ul>
+ * </p>
+ * @param name the name of the rule set; never null
+ * @param ruleSetNode the node representing the rule set; null if the rule set doesn't exist
+ * @return the rule set for the information stored in the repository, or null if the rule set does not exist or has errors
+ */
+ protected RuleSet buildRuleSet( String name, Node ruleSetNode, JcrTools tools ) {
+ if (ruleSetNode == null) return null;
+
+ Problems problems = new Problems();
+ String description = tools.getPropertyAsString(ruleSetNode, "jcr:description", false, problems);
+ String classname = tools.getPropertyAsString(ruleSetNode, "dna:classname", true, problems);
+ String[] classpath = tools.getPropertyAsStringArray(ruleSetNode, "dna:classpath", false, problems);
+ String providerUri = tools.getPropertyAsString(ruleSetNode, "dna:serviceProviderUri", true, problems);
+ String ruleSetUri = tools.getPropertyAsString(ruleSetNode, "dna:ruleSetUri", true, name, problems);
+ String rules = tools.getPropertyAsString(ruleSetNode, "dna:rules", true, problems);
+ Map<String, Object> properties = tools.loadProperties(ruleSetNode, problems);
+ if (problems.hasProblems()) {
+ // There are problems, so store and save them, and then return null ...
+ try {
+ if (tools.storeProblems(ruleSetNode, problems)) ruleSetNode.save();
+ } catch (RepositoryException e) {
+ this.logger.error(e, RepositoryI18n.errorWritingProblemsOnRuleSet, tools.getReadable(ruleSetNode));
+ }
+ return null;
+ }
+ // There are no problems with this rule set, so make sure that there are no persisted problems anymore ...
+ try {
+ if (tools.removeProblems(ruleSetNode)) ruleSetNode.save();
+ } catch (RepositoryException e) {
+ this.logger.error(e, RepositoryI18n.errorWritingProblemsOnRuleSet, tools.getReadable(ruleSetNode));
+ }
+ return new RuleSet(name, description, classname, classpath, providerUri, ruleSetUri, rules, properties);
+ }
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/InvalidSequencerPathExpression.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/InvalidSequencerPathExpression.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/InvalidSequencerPathExpression.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,62 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.sequencers;
+
+
+/**
+ *
+ * @author Randall Hauch
+ */
+public class InvalidSequencerPathExpression extends RuntimeException {
+
+ /**
+ *
+ */
+ public InvalidSequencerPathExpression() {
+ }
+
+ /**
+ * @param message
+ */
+ public InvalidSequencerPathExpression( String message ) {
+ super(message);
+
+ }
+
+ /**
+ * @param cause
+ */
+ public InvalidSequencerPathExpression( Throwable cause ) {
+ super(cause);
+
+ }
+
+ /**
+ * @param message
+ * @param cause
+ */
+ public InvalidSequencerPathExpression( String message, Throwable cause ) {
+ super(message, cause);
+
+ }
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/Sequencer.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/Sequencer.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/Sequencer.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,100 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.sequencers;
+
+import java.util.Set;
+import javax.jcr.Node;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import net.jcip.annotations.ThreadSafe;
+import org.jboss.dna.common.component.Component;
+import org.jboss.dna.common.monitor.ProgressMonitor;
+import org.jboss.dna.repository.observation.NodeChange;
+import org.jboss.dna.repository.observation.NodeChangeListener;
+import org.jboss.dna.repository.observation.NodeChanges;
+import org.jboss.dna.repository.observation.ObservationService;
+import org.jboss.dna.repository.util.ExecutionContext;
+import org.jboss.dna.repository.util.RepositoryNodePath;
+
+/**
+ * The interface for a DNA sequencer, which sequences nodes and their content to extract additional information from the
+ * information.
+ * <p>
+ * Implementations must provide a no-argument constructor.
+ * </p>
+ * @author Randall Hauch
+ */
+ at ThreadSafe
+public interface Sequencer extends Component<SequencerConfig> {
+
+ /**
+ * Execute the sequencing operation on the supplied node, which has recently been created or changed. The implementation of
+ * this method is responsible for {@link ExecutionContext#getSessionFactory() getting sessions}, modifying the appropriate
+ * nodes, {@link Session#save() saving} any changes made by this sequencer, and {@link Session#logout() closing} all sessions
+ * (and any other acquired resources), even in the case of {@link ProgressMonitor#isCancelled() cancellation} or exceptions.
+ * <p>
+ * The {@link SequencingService} determines the sequencers that should be executed by monitoring the changes to one or more
+ * workspaces (it is a {@link NodeChangeListener} registered with the {@link ObservationService}). Changes in those
+ * workspaces are aggregated for each transaction, and organized into {@link NodeChanges changes for each node}. The
+ * SequencingService then determines for each {@link NodeChange set of changes to a node} the set of full paths to the
+ * properties that have changed and whether those paths {@link SequencerPathExpression#matcher(String) match} the sequencer's
+ * {@link SequencerConfig#getPathExpressions() path expressions}. Each path expression produces the path to the output node,
+ * and these output paths are accumulated and (with the original node that changed, the node change summary, and other
+ * information) supplied to the sequencer via this method.
+ * <p>
+ * It is possible that a sequencer is configured to apply to multiple properties on a node. So, in cases where multiple
+ * properties are changed on a single node (within a single repository transaction), the sequencer will only be executed once.
+ * Also, in such cases the sequencer's configuration may imply multiple output nodes, so it is left to the sequencer to define
+ * the behavior in such cases.
+ * </p>
+ * <p>
+ * This operation should report progress to the supplied {@link ProgressMonitor}. At the beginning of the operation, call
+ * {@link ProgressMonitor#beginTask(double, org.jboss.dna.common.i18n.I18n, Object...)} with a meaningful message describing
+ * the operation and a total for the amount of work that will be done by this sequencer. Then perform the sequencing work,
+ * periodically reporting work by specifying the {@link ProgressMonitor#worked(double) amount of work} that has was just
+ * completed or by {@link ProgressMonitor#createSubtask(double) creating a subtask} and reporting work against that subtask
+ * monitor.
+ * </p>
+ * <p>
+ * The implementation should also periodically check whether the operation has been
+ * {@link ProgressMonitor#isCancelled() cancelled}. If this method returns true, the implementation should abort all work as
+ * soon as possible and close any resources that were acquired or opened.
+ * </p>
+ * <p>
+ * Finally, the implementation should call {@link ProgressMonitor#done()} when the operation has finished.
+ * </p>
+ * @param input the node that has recently been created or changed; never null
+ * @param sequencedPropertyName the name of the property that caused this sequencer to be executed; never null and never empty
+ * @param changes the immutable summary of changes that occurred on the <code>input</code> node within the transaction;
+ * never null
+ * @param outputPaths the paths to the nodes where the sequencing content should be placed; never null and never empty, but
+ * the set may contain paths for non-existant nodes or may reference the <code>input</code> node
+ * @param context the context in which this sequencer is executing; never null
+ * @param progress the progress monitor that should be kept updated with the sequencer's progress and that should be
+ * frequently consulted as to whether this operation has been {@link ProgressMonitor#isCancelled() cancelled}.
+ * @throws RepositoryException if there is a problem while working with the repository
+ * @throws SequencerException if there is an error in this sequencer
+ */
+ void execute( Node input, String sequencedPropertyName, NodeChange changes, Set<RepositoryNodePath> outputPaths, ExecutionContext context, ProgressMonitor progress )
+ throws RepositoryException, SequencerException;
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerConfig.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerConfig.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerConfig.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,75 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.sequencers;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import net.jcip.annotations.Immutable;
+import org.jboss.dna.common.component.ComponentConfig;
+
+/**
+ * @author Randall Hauch
+ */
+ at Immutable
+public class SequencerConfig extends ComponentConfig {
+
+ private final Set<SequencerPathExpression> pathExpressions;
+
+ public SequencerConfig( String name, String description, String classname, String[] classpath, String... pathExpressions ) {
+ this(name, description, System.currentTimeMillis(), classname, classpath, pathExpressions);
+ }
+
+ public SequencerConfig( String name, String description, long timestamp, String classname, String[] classpath, String... pathExpressions ) {
+ super(name, description, timestamp, classname, classpath);
+ this.pathExpressions = buildPathExpressionSet(pathExpressions);
+ }
+
+ /* package */static Set<SequencerPathExpression> buildPathExpressionSet( String... pathExpressions ) {
+ Set<SequencerPathExpression> result = null;
+ if (pathExpressions != null) {
+ result = new LinkedHashSet<SequencerPathExpression>();
+ for (String pathExpression : pathExpressions) {
+ if (pathExpression == null) continue;
+ pathExpression = pathExpression.trim();
+ if (pathExpression.length() == 0) continue;
+ result.add(SequencerPathExpression.compile(pathExpression));
+ }
+ result = Collections.unmodifiableSet(result);
+ } else {
+ result = Collections.emptySet(); // already immutable
+ }
+ return result;
+ }
+
+ public Collection<SequencerPathExpression> getPathExpressions() {
+ return Collections.unmodifiableSet(this.pathExpressions);
+ }
+
+ public boolean hasChanged( SequencerConfig that ) {
+ if (super.hasChanged(that)) return true;
+ if (!this.getPathExpressions().equals(that.getPathExpressions())) return true;
+ return false;
+ }
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerException.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerException.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerException.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,56 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.sequencers;
+
+/**
+ * @author Randall Hauch
+ */
+public class SequencerException extends RuntimeException {
+
+ /**
+ */
+ public SequencerException() {
+ }
+
+ /**
+ * @param message
+ */
+ public SequencerException( String message ) {
+ super(message);
+ }
+
+ /**
+ * @param cause
+ */
+ public SequencerException( Throwable cause ) {
+ super(cause);
+ }
+
+ /**
+ * @param message
+ * @param cause
+ */
+ public SequencerException( String message, Throwable cause ) {
+ super(message, cause);
+ }
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerOutputMap.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerOutputMap.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerOutputMap.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,316 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.sequencers;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import net.jcip.annotations.Immutable;
+import net.jcip.annotations.NotThreadSafe;
+import org.jboss.dna.common.jcr.Path;
+import org.jboss.dna.common.util.StringUtil;
+import org.jboss.dna.spi.sequencers.SequencerOutput;
+
+/**
+ * A basic {@link SequencerOutput} that records all information in-memory and which organizes the properties by
+ * {@link Path node paths} and provides access to the nodes in a natural path-order.
+ * @author Randall Hauch
+ */
+ at NotThreadSafe
+public class SequencerOutputMap implements SequencerOutput, Iterable<SequencerOutputMap.Entry> {
+
+ private static final String JCR_PRIMARY_TYPE_PROPERTY_NAME = "jcr:primaryType";
+ private static final String JCR_NAME_PROPERTY_NAME = "jcr:name";
+
+ private final Map<Path, List<PropertyValue>> data;
+ private boolean valuesSorted = true;
+
+ public SequencerOutputMap() {
+ this.data = new HashMap<Path, List<PropertyValue>>();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void setProperty( String nodePath, String property, Object... values ) {
+ property = property.trim();
+ if (JCR_NAME_PROPERTY_NAME.equals(property)) return; // ignore the "jcr:name" property
+ nodePath = nodePath.trim();
+ if (nodePath.endsWith("/")) nodePath = nodePath.replaceFirst("/+$", "");
+
+ // Find or create the entry for this node ...
+ Path path = new Path(nodePath);
+ List<PropertyValue> properties = this.data.get(path);
+ if (properties == null) {
+ if (values == null || values.length == 0) return; // do nothing
+ properties = new ArrayList<PropertyValue>();
+ this.data.put(path, properties);
+ }
+ if (values == null || values.length == 0) {
+ properties.remove(new PropertyValue(property, null));
+ } else {
+ Object propValue = values.length == 1 ? values[0] : values;
+ PropertyValue value = new PropertyValue(property, propValue);
+ properties.add(value);
+ valuesSorted = false;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void setReference( String nodePath, String property, String... paths ) {
+ if (paths == null || paths.length == 0) {
+ setProperty(nodePath, property, (Object[])null);
+ } else if (paths.length == 1) {
+ setProperty(nodePath, property, new Path(paths[0]));
+ } else {
+ Path[] pathsArray = new Path[paths.length];
+ for (int i = 0; i != paths.length; ++i) {
+ pathsArray[i] = new Path(paths[i]);
+ }
+ setProperty(nodePath, property, (Object[])pathsArray);
+ }
+ }
+
+ /**
+ * Return the number of node entries in this map.
+ * @return the number of entries
+ */
+ public int size() {
+ return this.data.size();
+ }
+
+ /**
+ * Return whether there are no entries
+ * @return true if this container is empty, or false otherwise
+ */
+ public boolean isEmpty() {
+ return this.data.isEmpty();
+ }
+
+ protected List<PropertyValue> removeProperties( Path nodePath ) {
+ return this.data.remove(nodePath);
+ }
+
+ /**
+ * Get the properties for the node given by the supplied path.
+ * @param nodePath the path to the node
+ * @return the property values, or null if there are none
+ */
+ protected List<PropertyValue> getProperties( Path nodePath ) {
+ return data.get(nodePath);
+ }
+
+ /**
+ * Return the entries in this output in an order with shorter paths first.
+ * <p>
+ * {@inheritDoc}
+ */
+ public Iterator<Entry> iterator() {
+ LinkedList<Path> paths = new LinkedList<Path>(data.keySet());
+ Collections.sort(paths);
+ sortValues();
+ return new EntryIterator(paths.iterator());
+ }
+
+ protected void sortValues() {
+ if (!valuesSorted) {
+ for (List<PropertyValue> values : this.data.values()) {
+ if (values.size() > 1) Collections.sort(values);
+ }
+ valuesSorted = true;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return StringUtil.readableString(this.data);
+ }
+
+ /**
+ * A property name and value pair. PropertyValue instances have a natural order where the <code>jcr:primaryType</code> is
+ * first, followed by all other properties in ascending lexicographical order according to the {@link #getName() name}.
+ * @author Randall Hauch
+ */
+ @Immutable
+ public class PropertyValue implements Comparable<PropertyValue> {
+
+ private final String name;
+ private final Object value;
+
+ protected PropertyValue( String propertyName, Object value ) {
+ this.name = propertyName;
+ this.value = value;
+ }
+
+ /**
+ * Get the property name.
+ * @return the property name; never null
+ */
+ public String getName() {
+ return this.name;
+ }
+
+ /**
+ * Get the property value, which is either a single value or an array of values.
+ * @return the property value
+ */
+ public Object getValue() {
+ return this.value;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public int compareTo( PropertyValue that ) {
+ if (this == that) return 0;
+ if (this.name.equals(JCR_PRIMARY_TYPE_PROPERTY_NAME)) return -1;
+ if (that.name.equals(JCR_PRIMARY_TYPE_PROPERTY_NAME)) return 1;
+ return this.name.compareTo(that.name);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int hashCode() {
+ return this.name.hashCode();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals( Object obj ) {
+ if (obj == this) return true;
+ if (obj instanceof PropertyValue) {
+ PropertyValue that = (PropertyValue)obj;
+ if (!this.getName().equals(that.getName())) return false;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return "[" + this.name + "=" + StringUtil.readableString(value) + "]";
+ }
+ }
+
+ /**
+ * An entry in a SequencerOutputMap, which contains the path of the node and the {@link #getPropertyValues() property values}
+ * on the node.
+ * @author Randall Hauch
+ */
+ @Immutable
+ public class Entry {
+
+ private final Path path;
+ private final String primaryType;
+ private final List<PropertyValue> properties;
+
+ protected Entry( Path path, List<PropertyValue> properties ) {
+ assert path != null;
+ assert properties != null;
+ this.path = path;
+ this.properties = properties;
+ if (this.properties.size() > 0 && this.properties.get(0).getName().equals("jcr:primaryType")) {
+ PropertyValue primaryTypeProperty = this.properties.remove(0);
+ this.primaryType = primaryTypeProperty.getValue().toString();
+ } else {
+ this.primaryType = null;
+ }
+ }
+
+ /**
+ * @return path
+ */
+ public Path getPath() {
+ return this.path;
+ }
+
+ /**
+ * Get the primary type specified for this node, or null if the type was not specified
+ * @return the primary type, or null
+ */
+ public String getPrimaryTypeValue() {
+ return this.primaryType;
+ }
+
+ /**
+ * Get the property values, which may be empty
+ * @return value
+ */
+ public List<PropertyValue> getPropertyValues() {
+ return getProperties(path);
+ }
+ }
+
+ protected class EntryIterator implements Iterator<Entry> {
+
+ private Path last;
+ private final Iterator<Path> iter;
+
+ protected EntryIterator( Iterator<Path> iter ) {
+ this.iter = iter;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean hasNext() {
+ return iter.hasNext();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Entry next() {
+ this.last = iter.next();
+ return new Entry(last, getProperties(last));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void remove() {
+ if (last == null) throw new IllegalStateException();
+ try {
+ removeProperties(last);
+ } finally {
+ last = null;
+ }
+ }
+ }
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerPathExpression.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerPathExpression.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencerPathExpression.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,476 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.sequencers;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+import net.jcip.annotations.Immutable;
+import org.jboss.dna.common.util.ArgCheck;
+import org.jboss.dna.common.util.HashCode;
+import org.jboss.dna.repository.RepositoryI18n;
+
+/**
+ * An expression that defines a selection of some change in the repository that signals a sequencing operation should be run, and
+ * the location where the sequencing output should be placed. Sequencer path expressions are used within the
+ * {@link SequencerConfig sequencer configurations} and used to determine whether information in the repository needs to be
+ * sequenced.
+ * <p>
+ * A simple example is the following:
+ *
+ * <pre>
+ * /a/b/c at title => /d/e/f
+ * </pre>
+ *
+ * which means that a sequencer (that uses this expression in its configuration) should be run any time there is a new or modified
+ * <code>title</code> property on the <code>/a/b/c</code> node, and that the output of the sequencing should be placed at
+ * <code>/d/e/f</code>.
+ * </p>
+ * @author Randall Hauch
+ */
+ at Immutable
+public class SequencerPathExpression implements Serializable {
+
+ /**
+ * The pattern used to break the initial input string into the two major parts, the selection and output expressions. Group 1
+ * contains the selection expression, and group 2 contains the output expression.
+ */
+ private static final Pattern TWO_PART_PATTERN = Pattern.compile("((?:[^=]|=(?!>))+)(?:=>(.+))?");
+
+ protected static final String DEFAULT_OUTPUT_EXPRESSION = ".";
+
+ private static final String REPLACEMENT_VARIABLE_PATTERN_STRING = "(?<!\\\\)\\$(\\d+)"; // (?<!\\)\$(\d+)
+ private static final Pattern REPLACEMENT_VARIABLE_PATTERN = Pattern.compile(REPLACEMENT_VARIABLE_PATTERN_STRING);
+
+ private static final String PARENT_PATTERN_STRING = "[^/]+/\\.\\./"; // [^/]+/\.\./
+ private static final Pattern PARENT_PATTERN = Pattern.compile(PARENT_PATTERN_STRING);
+
+ private static final String SEQUENCE_PATTERN_STRING = "\\[(\\d+(?:,\\d+)*)\\]"; // \[(\d+(,\d+)*)\]
+ private static final Pattern SEQUENCE_PATTERN = Pattern.compile(SEQUENCE_PATTERN_STRING);
+
+ /**
+ * Regular expression used to find unusable XPath predicates within an expression. This pattern results in unusable predicates
+ * in group 1. Note that some predicates may be valid at the end but not valid elsewhere.
+ * <p>
+ * Currently, only index-like predicates (including sequences) are allowed everywhere. Predicates with paths and properties
+ * are allowed only as the last predicate. Predicates with any operators are unused.
+ * </p>
+ * <p>
+ * Nested predicates are not currently allowed.
+ * </p>
+ */
+ // \[(?:(?:\d+(?:,\d+)*)|\*)\]|(?:\[[^\]\+\-\*=\!><'"\s]+\])$|(\[[^\]]+\])
+ private static final String UNUSABLE_PREDICATE_PATTERN_STRING = "\\[(?:(?:\\d+(?:,\\d+)*)|\\*)\\]|(?:\\[[^\\]\\+\\-\\*=\\!><'\"\\s]+\\])$|(\\[[^\\]]+\\])";
+ private static final Pattern UNUSABLE_PREDICATE_PATTERN = Pattern.compile(UNUSABLE_PREDICATE_PATTERN_STRING);
+
+ /**
+ * Regular expression used to find all XPath predicates except index and sequence patterns. This pattern results in the
+ * predicates to be removed in group 1.
+ */
+ // \[(?:(?:\d+(?:,\d+)*)|\*)\]|(\[[^\]]+\])
+ private static final String NON_INDEX_PREDICATE_PATTERN_STRING = "\\[(?:(?:\\d+(?:,\\d+)*)|\\*)\\]|(\\[[^\\]]+\\])";
+ private static final Pattern NON_INDEX_PREDICATE_PATTERN = Pattern.compile(NON_INDEX_PREDICATE_PATTERN_STRING);
+
+ /**
+ * Compile the supplied expression and return the resulting SequencerPathExpression2 instance.
+ * @param expression the expression
+ * @return the path expression; never null
+ * @throws IllegalArgumentException if the expression is null
+ * @throws InvalidSequencerPathExpression if the expression is blank or is not a valid expression
+ */
+ public static final SequencerPathExpression compile( String expression ) throws InvalidSequencerPathExpression {
+ ArgCheck.isNotNull(expression, "sequencer path expression");
+ expression = expression.trim();
+ if (expression.length() == 0) {
+ throw new InvalidSequencerPathExpression(RepositoryI18n.pathExpressionMayNotBeBlank.text());
+ }
+ java.util.regex.Matcher matcher = TWO_PART_PATTERN.matcher(expression);
+ if (!matcher.matches()) {
+ throw new InvalidSequencerPathExpression(RepositoryI18n.pathExpressionIsInvalid.text(expression));
+ }
+ String selectExpression = matcher.group(1);
+ String outputExpression = matcher.group(2);
+ return new SequencerPathExpression(selectExpression, outputExpression);
+ }
+
+ private final String selectExpression;
+ private final String outputExpression;
+ private final Pattern matchPattern;
+ private final Pattern selectPattern;
+ private final int hc;
+
+ protected SequencerPathExpression( String selectExpression, String outputExpression ) throws InvalidSequencerPathExpression {
+ ArgCheck.isNotNull(selectExpression, "select expression");
+ this.selectExpression = selectExpression.trim();
+ this.outputExpression = outputExpression != null ? outputExpression.trim() : DEFAULT_OUTPUT_EXPRESSION;
+ this.hc = HashCode.compute(this.selectExpression, this.outputExpression);
+
+ // Build the match pattern, which determines whether a path matches the condition ...
+ String matchString = this.selectExpression;
+ try {
+ matchString = removeUnusedPredicates(matchString);
+ matchString = replaceXPathPatterns(matchString);
+ this.matchPattern = Pattern.compile(matchString, Pattern.CASE_INSENSITIVE);
+ } catch (PatternSyntaxException e) {
+ String msg = RepositoryI18n.pathExpressionHasInvalidMatch.text(matchString, this.selectExpression, this.outputExpression);
+ throw new InvalidSequencerPathExpression(msg, e);
+ }
+ // Build the select pattern, which determines the path that will be selected ...
+ String selectString = this.selectExpression.trim();
+ try {
+ selectString = removeAllPredicatesExceptIndexes(selectString);
+ selectString = replaceXPathPatterns(selectString);
+ selectString = "(" + selectString + ").*"; // group 1 will have selected path ...
+ this.selectPattern = Pattern.compile(selectString, Pattern.CASE_INSENSITIVE);
+ } catch (PatternSyntaxException e) {
+ String msg = RepositoryI18n.pathExpressionHasInvalidSelect.text(selectString, this.selectExpression, this.outputExpression);
+ throw new InvalidSequencerPathExpression(msg, e);
+ }
+ }
+
+ /**
+ * Replace certain XPath patterns that are not used or understood.
+ * @param expression the input regular expressions string; may not be null
+ * @return the regular expression with all unused XPath patterns removed; never null
+ */
+ protected String removeUnusedPredicates( String expression ) {
+ assert expression != null;
+ java.util.regex.Matcher matcher = UNUSABLE_PREDICATE_PATTERN.matcher(expression);
+ StringBuffer sb = new StringBuffer();
+ if (matcher.find()) {
+ do {
+ // Remove those predicates that show up in group 1 ...
+ String predicateStr = matcher.group(0);
+ String unusablePredicateStr = matcher.group(1);
+ if (unusablePredicateStr != null) {
+ predicateStr = "";
+ }
+ matcher.appendReplacement(sb, predicateStr);
+ } while (matcher.find());
+ matcher.appendTail(sb);
+ expression = sb.toString();
+ }
+ return expression;
+ }
+
+ /**
+ * Remove all XPath predicates from the supplied regular expression string.
+ * @param expression the input regular expressions string; may not be null
+ * @return the regular expression with all XPath predicates removed; never null
+ */
+ protected String removeAllPredicatesExceptIndexes( String expression ) {
+ assert expression != null;
+ java.util.regex.Matcher matcher = NON_INDEX_PREDICATE_PATTERN.matcher(expression);
+ StringBuffer sb = new StringBuffer();
+ if (matcher.find()) {
+ do {
+ // Remove those predicates that show up in group 1 ...
+ String predicateStr = matcher.group(0);
+ String unusablePredicateStr = matcher.group(1);
+ if (unusablePredicateStr != null) {
+ predicateStr = "";
+ }
+ matcher.appendReplacement(sb, predicateStr);
+ } while (matcher.find());
+ matcher.appendTail(sb);
+ expression = sb.toString();
+ }
+ return expression;
+ }
+
+ /**
+ * Replace certain XPath patterns, including some predicates, with substrings that are compatible with regular expressions.
+ * @param expression the input regular expressions string; may not be null
+ * @return the regular expression with XPath patterns replaced with regular expression fragments; never null
+ */
+ protected String replaceXPathPatterns( String expression ) {
+ assert expression != null;
+ // replace 2 or more sequential '|' characters in an OR expression
+ expression = expression.replaceAll("[\\|]{2,}", "|");
+ // if there is an empty expression in an OR expression, make the whole segment optional ...
+ // (e.g., "/a/b/(c|)/d" => "a/b(/(c))?/d"
+ expression = expression.replaceAll("/(\\([^|]+)(\\|){2,}([^)]+\\))", "(/$1$2$3)?");
+ expression = expression.replaceAll("/\\(\\|+([^)]+)\\)", "(/($1))?");
+ expression = expression.replaceAll("/\\((([^|]+)(\\|[^|]+)*)\\|+\\)", "(/($1))?");
+
+ // // Allow any path (that doesn't contain an explicit counter) to contain a counter,
+ // // done by replacing any '/' or '|' that isn't preceded by ']' or '*' or '/' or '(' with '(\[\d+\])?/'...
+ // input = input.replaceAll("(?<=[^\\]\\*/(])([/|])", "(?:\\\\[\\\\d+\\\\])?$1");
+
+ // Does the path contain any '[]' or '[*]' or '[0]' or '[n]' (where n is any positive integers)...
+ // '[*]/' => '(\[\d+\])?/'
+ expression = expression.replaceAll("\\[\\]", "(?:\\\\[\\\\d+\\\\])?"); // index is optional
+ // '[]/' => '(\[\d+\])?/'
+ expression = expression.replaceAll("\\[[*]\\]", "(?:\\\\[\\\\d+\\\\])?"); // index is optional
+ // '[0]/' => '(\[0\])?/'
+ expression = expression.replaceAll("\\[0\\]", "(?:\\\\[0\\\\])?"); // index is optional
+ // '[n]/' => '\[n\]/'
+ expression = expression.replaceAll("\\[([1-9]\\d*)\\]", "\\\\[$1\\\\]"); // index is required
+
+ // Change any other end predicates to not be wrapped by braces but to begin with a slash ...
+ // ...'[x]' => ...'/x'
+ expression = expression.replaceAll("(?<!\\\\)\\[([^\\]]*)\\]$", "/$1");
+
+ // Replace all '[n,m,o,p]' type sequences with '[(n|m|o|p)]'
+ java.util.regex.Matcher matcher = SEQUENCE_PATTERN.matcher(expression);
+ StringBuffer sb = new StringBuffer();
+ boolean result = matcher.find();
+ if (result) {
+ do {
+ String sequenceStr = matcher.group(1);
+ boolean optional = false;
+ if (sequenceStr.startsWith("0,")) {
+ sequenceStr = sequenceStr.replaceFirst("^0,", "");
+ optional = true;
+ }
+ if (sequenceStr.endsWith(",0")) {
+ sequenceStr = sequenceStr.replaceFirst(",0$", "");
+ optional = true;
+ }
+ if (sequenceStr.contains(",0,")) {
+ sequenceStr = sequenceStr.replaceAll(",0,", ",");
+ optional = true;
+ }
+ sequenceStr = sequenceStr.replaceAll(",", "|");
+ String replacement = "\\\\[(?:" + sequenceStr + ")\\\\]";
+ if (optional) {
+ replacement = "(?:" + replacement + ")?";
+ }
+ matcher.appendReplacement(sb, replacement);
+ result = matcher.find();
+ } while (result);
+ matcher.appendTail(sb);
+ expression = sb.toString();
+ }
+
+ // Order is important here
+ expression = expression.replaceAll("[*]", "[^/]*");
+ expression = expression.replaceAll("[/]{2,}", "(/[^/]*)*/");
+ return expression;
+ }
+
+ /**
+ * @return selectExpression
+ */
+ public String getSelectExpression() {
+ return this.selectExpression;
+ }
+
+ /**
+ * @return outputExpression
+ */
+ public String getOutputExpression() {
+ return this.outputExpression;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int hashCode() {
+ return this.hc;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals( Object obj ) {
+ if (obj == this) return true;
+ if (obj instanceof SequencerPathExpression) {
+ SequencerPathExpression that = (SequencerPathExpression)obj;
+ if (!this.selectExpression.equalsIgnoreCase(that.selectExpression)) return false;
+ if (!this.outputExpression.equalsIgnoreCase(that.outputExpression)) return false;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return this.selectExpression + "=>" + this.outputExpression;
+ }
+
+ /**
+ * @param absolutePath
+ * @return the matcher
+ */
+ public Matcher matcher( String absolutePath ) {
+ // Determine if the input path match the select expression ...
+ String originalAbsolutePath = absolutePath;
+ // if (!absolutePath.endsWith("/")) absolutePath = absolutePath + "/";
+ // Remove all trailing '/' ...
+ absolutePath = absolutePath.replaceAll("/+$", "");
+
+ // See if the supplied absolute path matches the pattern ...
+ final java.util.regex.Matcher matcher = this.matchPattern.matcher(absolutePath);
+ if (!matcher.matches()) {
+ // No match, so return immediately ...
+ return new Matcher(originalAbsolutePath, null, null);
+ }
+ Map<Integer, String> replacements = new HashMap<Integer, String>();
+ for (int i = 0, count = matcher.groupCount(); i <= count; ++i) {
+ replacements.put(i, matcher.group(i));
+ }
+
+ // The absolute path does match the pattern, so use the select pattern and try to grab the selected path ...
+ final java.util.regex.Matcher selectMatcher = this.selectPattern.matcher(absolutePath);
+ if (!selectMatcher.matches()) {
+ // Nothing can be selected, so return immediately ...
+ return new Matcher(originalAbsolutePath, null, null);
+ }
+ // Grab the selected path ...
+ String selectedPath = selectMatcher.group(1);
+
+ // Remove the trailing '/@property' ...
+ selectedPath = selectedPath.replaceAll("/@[^/\\[\\]]+$", "");
+
+ // Find the output path using the groups from the match pattern ...
+ String outputPath = this.outputExpression;
+ if (!DEFAULT_OUTPUT_EXPRESSION.equals(outputPath)) {
+ java.util.regex.Matcher replacementMatcher = REPLACEMENT_VARIABLE_PATTERN.matcher(outputPath);
+ StringBuffer sb = new StringBuffer();
+ if (replacementMatcher.find()) {
+ do {
+ String variable = replacementMatcher.group(1);
+ String replacement = replacements.get(Integer.valueOf(variable));
+ if (replacement == null) replacement = replacementMatcher.group(0);
+ replacementMatcher.appendReplacement(sb, replacement);
+ } while (replacementMatcher.find());
+ replacementMatcher.appendTail(sb);
+ outputPath = sb.toString();
+ }
+ // Make sure there is a trailing '/' ...
+ if (!outputPath.endsWith("/")) outputPath = outputPath + "/";
+
+ // Replace all references to "/./" with "/" ...
+ outputPath = outputPath.replaceAll("/\\./", "/");
+
+ // Remove any path segment followed by a parent reference ...
+ java.util.regex.Matcher parentMatcher = PARENT_PATTERN.matcher(outputPath);
+ while (parentMatcher.find()) {
+ outputPath = parentMatcher.replaceAll("");
+ // Make sure there is a trailing '/' ...
+ if (!outputPath.endsWith("/")) outputPath = outputPath + "/";
+ parentMatcher = PARENT_PATTERN.matcher(outputPath);
+ }
+
+ // Remove all multiple occurrences of '/' ...
+ outputPath = outputPath.replaceAll("/{2,}", "/");
+
+ // Remove the trailing '/@property' ...
+ outputPath = outputPath.replaceAll("/@[^/\\[\\]]+$", "");
+
+ // Remove a trailing '/' ...
+ outputPath = outputPath.replaceAll("/$", "");
+
+ // If the output path is blank, then use the default output expression ...
+ if (outputPath.length() == 0) outputPath = DEFAULT_OUTPUT_EXPRESSION;
+
+ }
+ if (DEFAULT_OUTPUT_EXPRESSION.equals(outputPath)) {
+ // The output path is the default expression, so use the selected path ...
+ outputPath = selectedPath;
+ }
+
+ return new Matcher(originalAbsolutePath, selectedPath, outputPath);
+ }
+
+ @Immutable
+ public static class Matcher {
+
+ private final String inputPath;
+ private final String selectedPath;
+ private final String outputPath;
+ private final int hc;
+
+ protected Matcher( String inputPath, String selectedPath, String outputPath ) {
+ this.inputPath = inputPath;
+ this.selectedPath = selectedPath;
+ this.outputPath = outputPath;
+ this.hc = HashCode.compute(this.inputPath, this.selectedPath, this.outputPath);
+ }
+
+ public boolean matches() {
+ return this.selectedPath != null && this.outputPath != null;
+ }
+
+ /**
+ * @return inputPath
+ */
+ public String getInputPath() {
+ return this.inputPath;
+ }
+
+ /**
+ * @return selectPattern
+ */
+ public String getSelectedPath() {
+ return this.selectedPath;
+ }
+
+ /**
+ * @return outputPath
+ */
+ public String getOutputPath() {
+ return this.outputPath;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int hashCode() {
+ return this.hc;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals( Object obj ) {
+ if (obj == this) return true;
+ if (obj instanceof SequencerPathExpression.Matcher) {
+ SequencerPathExpression.Matcher that = (SequencerPathExpression.Matcher)obj;
+ if (!this.inputPath.equalsIgnoreCase(that.inputPath)) return false;
+ if (!this.selectedPath.equalsIgnoreCase(that.selectedPath)) return false;
+ if (!this.outputPath.equalsIgnoreCase(that.outputPath)) return false;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return this.selectedPath + " => " + this.outputPath;
+ }
+ }
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencingService.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencingService.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/SequencingService.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,710 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.sequencers;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import javax.jcr.Node;
+import javax.jcr.Repository;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.observation.Event;
+import net.jcip.annotations.Immutable;
+import net.jcip.annotations.ThreadSafe;
+import org.jboss.dna.common.component.ClassLoaderFactory;
+import org.jboss.dna.common.component.ComponentLibrary;
+import org.jboss.dna.common.component.StandardClassLoaderFactory;
+import org.jboss.dna.common.monitor.LoggingProgressMonitor;
+import org.jboss.dna.common.monitor.ProgressMonitor;
+import org.jboss.dna.common.monitor.SimpleProgressMonitor;
+import org.jboss.dna.common.util.ArgCheck;
+import org.jboss.dna.common.util.HashCode;
+import org.jboss.dna.common.util.Logger;
+import org.jboss.dna.repository.RepositoryI18n;
+import org.jboss.dna.repository.observation.NodeChange;
+import org.jboss.dna.repository.observation.NodeChangeListener;
+import org.jboss.dna.repository.observation.NodeChanges;
+import org.jboss.dna.repository.services.AbstractServiceAdministrator;
+import org.jboss.dna.repository.services.AdministeredService;
+import org.jboss.dna.repository.services.ServiceAdministrator;
+import org.jboss.dna.repository.util.ExecutionContext;
+import org.jboss.dna.repository.util.JcrTools;
+import org.jboss.dna.repository.util.RepositoryNodePath;
+import org.jboss.dna.repository.util.SessionFactory;
+
+/**
+ * A sequencing system is used to monitor changes in the content of {@link Repository JCR repositories} and to sequence the
+ * content to extract or to generate structured information.
+ * @author Randall Hauch
+ */
+public class SequencingService implements AdministeredService, NodeChangeListener {
+
+ /**
+ * Interface used to select the set of {@link Sequencer} instances that should be run.
+ * @author Randall Hauch
+ */
+ public static interface Selector {
+
+ /**
+ * Select the sequencers that should be used to sequence the supplied node.
+ * @param sequencers the list of all sequencers available at the moment; never null
+ * @param node the node to be sequenced; never null
+ * @param nodeChange the set of node changes; never null
+ * @return the list of sequencers that should be used; may not be null
+ */
+ List<Sequencer> selectSequencers( List<Sequencer> sequencers, Node node, NodeChange nodeChange );
+ }
+
+ /**
+ * The default {@link Selector} implementation that selects every sequencer every time it's called, regardless of the node (or
+ * logger) supplied.
+ * @author Randall Hauch
+ */
+ protected static class DefaultSelector implements Selector {
+
+ public List<Sequencer> selectSequencers( List<Sequencer> sequencers, Node node, NodeChange nodeChange ) {
+ return sequencers;
+ }
+ }
+
+ /**
+ * Interface used to determine whether a {@link NodeChange} should be processed.
+ * @author Randall Hauch
+ */
+ public static interface NodeFilter {
+
+ /**
+ * Determine whether the node represented by the supplied change should be submitted for sequencing.
+ * @param nodeChange the node change event
+ * @return true if the node should be submitted for sequencing, or false if the change should be ignored
+ */
+ boolean accept( NodeChange nodeChange );
+ }
+
+ /**
+ * The default filter implementation, which accepts only new nodes or nodes that have new or changed properties.
+ * @author Randall Hauch
+ */
+ protected static class DefaultNodeFilter implements NodeFilter {
+
+ public boolean accept( NodeChange nodeChange ) {
+ // Only care about new nodes or nodes that have new/changed properies ...
+ return nodeChange.includesEventTypes(Event.NODE_ADDED, Event.PROPERTY_ADDED, Event.PROPERTY_CHANGED);
+ }
+ }
+
+ /**
+ * The default {@link Selector} that considers every {@link Sequencer} to be used for every node.
+ * @see SequencingService#setSequencerSelector(org.jboss.dna.repository.sequencers.SequencingService.Selector)
+ */
+ public static final Selector DEFAULT_SEQUENCER_SELECTOR = new DefaultSelector();
+ /**
+ * The default {@link NodeFilter} that accepts new nodes or nodes that have new/changed properties.
+ * @see SequencingService#setSequencerSelector(org.jboss.dna.repository.sequencers.SequencingService.Selector)
+ */
+ public static final NodeFilter DEFAULT_NODE_FILTER = new DefaultNodeFilter();
+
+ /**
+ * Class loader factory instance that always returns the
+ * {@link Thread#getContextClassLoader() current thread's context class loader} (if not null) or component library's class
+ * loader.
+ */
+ protected static final ClassLoaderFactory DEFAULT_CLASSLOADER_FACTORY = new StandardClassLoaderFactory(SequencingService.class.getClassLoader());
+
+ /**
+ * The administrative component for this service.
+ * @author Randall Hauch
+ */
+ protected class Administrator extends AbstractServiceAdministrator {
+
+ protected Administrator() {
+ super(State.PAUSED);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected String serviceName() {
+ return RepositoryI18n.sequencingServiceName.text();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected void doStart( State fromState ) {
+ super.doStart(fromState);
+ startService();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected void doShutdown( State fromState ) {
+ super.doShutdown(fromState);
+ shutdownService();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean awaitTermination( long timeout, TimeUnit unit ) throws InterruptedException {
+ return doAwaitTermination(timeout, unit);
+ }
+
+ }
+
+ private ExecutionContext executionContext;
+ private ComponentLibrary<Sequencer, SequencerConfig> sequencerLibrary = new ComponentLibrary<Sequencer, SequencerConfig>();
+ private Selector sequencerSelector = DEFAULT_SEQUENCER_SELECTOR;
+ private NodeFilter nodeFilter = DEFAULT_NODE_FILTER;
+ private ExecutorService executorService;
+ private Logger logger = Logger.getLogger(this.getClass());
+ private final Statistics statistics = new Statistics();
+ private final Administrator administrator = new Administrator();
+
+ /**
+ * Create a new sequencing system, configured with no sequencers and not monitoring any workspaces. Upon construction, the
+ * system is {@link ServiceAdministrator#isPaused() paused} and must be configured and then
+ * {@link ServiceAdministrator#start() started}.
+ */
+ public SequencingService() {
+ this.sequencerLibrary.setClassLoaderFactory(DEFAULT_CLASSLOADER_FACTORY);
+ }
+
+ /**
+ * Return the administrative component for this service.
+ * @return the administrative component; never null
+ */
+ public ServiceAdministrator getAdministrator() {
+ return this.administrator;
+ }
+
+ /**
+ * Get the statistics for this system.
+ * @return statistics
+ */
+ public Statistics getStatistics() {
+ return this.statistics;
+ }
+
+ /**
+ * @return sequencerLibrary
+ */
+ protected ComponentLibrary<Sequencer, SequencerConfig> getSequencerLibrary() {
+ return this.sequencerLibrary;
+ }
+
+ /**
+ * Get the class loader factory that should be used to load sequencers. By default, this service uses a factory that will
+ * return either the {@link Thread#getContextClassLoader() current thread's context class loader} (if not null) or the class
+ * loader that loaded this class.
+ * @return the class loader factory; never null
+ * @see #setClassLoaderFactory(ClassLoaderFactory)
+ */
+ public ClassLoaderFactory getClassLoaderFactory() {
+ return this.sequencerLibrary.getClassLoaderFactory();
+ }
+
+ /**
+ * Set the Maven Repository that should be used to load the sequencer classes. By default, this service uses a class loader
+ * factory that will return either the {@link Thread#getContextClassLoader() current thread's context class loader} (if not
+ * null) or the class loader that loaded this class.
+ * @param classLoaderFactory the class loader factory reference, or null if the default class loader factory should be used.
+ * @see #getClassLoaderFactory()
+ */
+ public void setClassLoaderFactory( ClassLoaderFactory classLoaderFactory ) {
+ this.sequencerLibrary.setClassLoaderFactory(classLoaderFactory != null ? classLoaderFactory : DEFAULT_CLASSLOADER_FACTORY);
+ }
+
+ /**
+ * Add the configuration for a sequencer, or update any existing one that represents the
+ * {@link SequencerConfig#equals(Object) same configuration}
+ * @param config the new configuration
+ * @return true if the sequencer was added, or false if there already was an existing and
+ * {@link SequencerConfig#hasChanged(SequencerConfig) unchanged} sequencer configuration
+ * @throws IllegalArgumentException if <code>config</code> is null
+ * @see #updateSequencer(SequencerConfig)
+ * @see #removeSequencer(SequencerConfig)
+ */
+ public boolean addSequencer( SequencerConfig config ) {
+ return this.sequencerLibrary.add(config);
+ }
+
+ /**
+ * Update the configuration for a sequencer, or add it if there is no
+ * {@link SequencerConfig#equals(Object) matching configuration}.
+ * @param config the updated (or new) configuration
+ * @return true if the sequencer was updated, or false if there already was an existing and
+ * {@link SequencerConfig#hasChanged(SequencerConfig) unchanged} sequencer configuration
+ * @throws IllegalArgumentException if <code>config</code> is null
+ * @see #addSequencer(SequencerConfig)
+ * @see #removeSequencer(SequencerConfig)
+ */
+ public boolean updateSequencer( SequencerConfig config ) {
+ return this.sequencerLibrary.update(config);
+ }
+
+ /**
+ * Remove the configuration for a sequencer.
+ * @param config the configuration to be removed
+ * @return true if the sequencer was removed, or false if there was no existing sequencer
+ * @throws IllegalArgumentException if <code>config</code> is null
+ * @see #addSequencer(SequencerConfig)
+ * @see #updateSequencer(SequencerConfig)
+ */
+ public boolean removeSequencer( SequencerConfig config ) {
+ return this.sequencerLibrary.remove(config);
+ }
+
+ /**
+ * Get the logger for this system
+ * @return the logger
+ */
+ public Logger getLogger() {
+ return this.logger;
+ }
+
+ /**
+ * Set the logger for this system.
+ * @param logger the logger, or null if the standard logging should be used
+ */
+ public void setLogger( Logger logger ) {
+ this.logger = logger != null ? logger : Logger.getLogger(this.getClass());
+ }
+
+ /**
+ * @return executionContext
+ */
+ public ExecutionContext getExecutionContext() {
+ return this.executionContext;
+ }
+
+ /**
+ * @param executionContext Sets executionContext to the specified value.
+ */
+ public void setExecutionContext( ExecutionContext executionContext ) {
+ ArgCheck.isNotNull(executionContext, "execution context");
+ if (this.getAdministrator().isStarted()) {
+ throw new IllegalStateException(RepositoryI18n.unableToChangeExecutionContextWhileRunning.text());
+ }
+ this.executionContext = executionContext;
+ }
+
+ /**
+ * Get the executor service used to run the sequencers.
+ * @return the executor service
+ * @see #setExecutorService(ExecutorService)
+ */
+ public ExecutorService getExecutorService() {
+ return this.executorService;
+ }
+
+ /**
+ * Set the executor service that should be used by this system. By default, the system is set up with a
+ * {@link Executors#newSingleThreadExecutor() executor that uses a single thread}.
+ * @param executorService the executor service
+ * @see #getExecutorService()
+ * @see Executors#newCachedThreadPool()
+ * @see Executors#newCachedThreadPool(java.util.concurrent.ThreadFactory)
+ * @see Executors#newFixedThreadPool(int)
+ * @see Executors#newFixedThreadPool(int, java.util.concurrent.ThreadFactory)
+ * @see Executors#newScheduledThreadPool(int)
+ * @see Executors#newScheduledThreadPool(int, java.util.concurrent.ThreadFactory)
+ * @see Executors#newSingleThreadExecutor()
+ * @see Executors#newSingleThreadExecutor(java.util.concurrent.ThreadFactory)
+ * @see Executors#newSingleThreadScheduledExecutor()
+ * @see Executors#newSingleThreadScheduledExecutor(java.util.concurrent.ThreadFactory)
+ */
+ public void setExecutorService( ExecutorService executorService ) {
+ ArgCheck.isNotNull(executorService, "executor service");
+ if (this.getAdministrator().isStarted()) {
+ throw new IllegalStateException(RepositoryI18n.unableToChangeExecutionContextWhileRunning.text());
+ }
+ this.executorService = executorService;
+ }
+
+ /**
+ * Override this method to creates a different kind of default executor service. This method is called when the system is
+ * {@link #start() started} without an executor service being {@link #setExecutorService(ExecutorService) set}.
+ * <p>
+ * This method creates a {@link Executors#newSingleThreadExecutor() single-threaded executor}.
+ * </p>
+ * @return
+ */
+ protected ExecutorService createDefaultExecutorService() {
+ return Executors.newSingleThreadExecutor();
+ }
+
+ protected void startService() {
+ if (this.getExecutionContext() == null) {
+ throw new IllegalStateException(RepositoryI18n.unableToStartSequencingServiceWithoutExecutionContext.text());
+ }
+ if (this.executorService == null) {
+ this.executorService = createDefaultExecutorService();
+ }
+ assert this.executorService != null;
+ assert this.sequencerSelector != null;
+ assert this.nodeFilter != null;
+ assert this.sequencerLibrary != null;
+ }
+
+ protected void shutdownService() {
+ if (this.executorService != null) {
+ this.executorService.shutdown();
+ }
+ }
+
+ protected boolean doAwaitTermination( long timeout, TimeUnit unit ) throws InterruptedException {
+ if (this.executorService.isShutdown()) return true;
+ return this.executorService.awaitTermination(timeout, unit);
+ }
+
+ /**
+ * Get the sequencing selector used by this system.
+ * @return the sequencing selector
+ */
+ public Selector getSequencerSelector() {
+ return this.sequencerSelector;
+ }
+
+ /**
+ * Set the sequencer selector, or null if the {@link #DEFAULT_SEQUENCER_SELECTOR default sequencer selector} should be used.
+ * @param sequencerSelector the selector
+ */
+ public void setSequencerSelector( Selector sequencerSelector ) {
+ this.sequencerSelector = sequencerSelector != null ? sequencerSelector : DEFAULT_SEQUENCER_SELECTOR;
+ }
+
+ /**
+ * Get the node filter used by this system.
+ * @return the node filter
+ */
+ public NodeFilter getNodeFilter() {
+ return this.nodeFilter;
+ }
+
+ /**
+ * Set the filter that checks which nodes are to be sequenced, or null if the {@link #DEFAULT_NODE_FILTER default node filter}
+ * should be used.
+ * @param nodeFilter the new node filter
+ */
+ public void setNodeFilter( NodeFilter nodeFilter ) {
+ this.nodeFilter = nodeFilter != null ? nodeFilter : DEFAULT_NODE_FILTER;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void onNodeChanges( NodeChanges changes ) {
+ NodeFilter filter = this.getNodeFilter();
+ for (final NodeChange changedNode : changes) {
+ // Only care about new nodes or nodes that have new/changed properies ...
+ if (filter.accept(changedNode)) {
+ this.executorService.execute(new Runnable() {
+
+ public void run() {
+ processChangedNode(changedNode);
+ }
+ });
+ }
+ }
+ }
+
+ /**
+ * Do the work of processing by sequencing the node. This method is called by the {@link #executorService executor service}
+ * when it performs it's work on the enqueued {@link ChangedNode ChangedNode runnable objects}.
+ * @param node the node to be processed.
+ */
+ protected void processChangedNode( NodeChange changedNode ) {
+ try {
+ final String repositoryWorkspaceName = changedNode.getRepositoryWorkspaceName();
+ Session session = null;
+ try {
+ // Figure out which sequencers accept this path,
+ // and track which output nodes should be passed to each sequencer...
+ final String nodePath = changedNode.getAbsolutePath();
+ Map<SequencerCall, Set<RepositoryNodePath>> sequencerCalls = new HashMap<SequencerCall, Set<RepositoryNodePath>>();
+ List<Sequencer> allSequencers = this.sequencerLibrary.getInstances();
+ List<Sequencer> sequencers = new ArrayList<Sequencer>(allSequencers.size());
+ for (Sequencer sequencer : allSequencers) {
+ final SequencerConfig config = sequencer.getConfiguration();
+ for (SequencerPathExpression pathExpression : config.getPathExpressions()) {
+ for (String propertyName : changedNode.getModifiedProperties()) {
+ String path = nodePath + "/@" + propertyName;
+ SequencerPathExpression.Matcher matcher = pathExpression.matcher(path);
+ if (matcher.matches()) {
+ // String selectedPath = matcher.getSelectedPath();
+ RepositoryNodePath outputPath = RepositoryNodePath.parse(matcher.getOutputPath(), repositoryWorkspaceName);
+ SequencerCall call = new SequencerCall(sequencer, propertyName);
+ // Record the output path ...
+ Set<RepositoryNodePath> outputPaths = sequencerCalls.get(call);
+ if (outputPaths == null) {
+ outputPaths = new HashSet<RepositoryNodePath>();
+ sequencerCalls.put(call, outputPaths);
+ }
+ outputPaths.add(outputPath);
+ sequencers.add(sequencer);
+ break;
+ }
+ }
+ }
+ }
+
+ Node node = null;
+ if (!sequencers.isEmpty()) {
+ // Create a session that we'll use for all sequencing ...
+ session = this.getExecutionContext().getSessionFactory().createSession(repositoryWorkspaceName);
+
+ // Find the changed node ...
+ String relPath = changedNode.getAbsolutePath().replaceAll("^/+", "");
+ node = session.getRootNode().getNode(relPath);
+
+ // Figure out which sequencers should run ...
+ sequencers = this.sequencerSelector.selectSequencers(sequencers, node, changedNode);
+ }
+ if (sequencers.isEmpty()) {
+ this.statistics.recordNodeSkipped();
+ if (this.logger.isDebugEnabled()) {
+ this.logger.trace("Skipping '{}': no sequencers matched this condition", changedNode);
+ }
+ } else {
+ // Run each of those sequencers ...
+ ProgressMonitor progressMonitor = new SimpleProgressMonitor(RepositoryI18n.sequencerTask.text(changedNode));
+ if (this.logger.isTraceEnabled()) {
+ progressMonitor = new LoggingProgressMonitor(progressMonitor, this.logger, Logger.Level.TRACE);
+ }
+ try {
+ progressMonitor.beginTask(sequencerCalls.size(), RepositoryI18n.sequencerTask, changedNode);
+ for (Map.Entry<SequencerCall, Set<RepositoryNodePath>> entry : sequencerCalls.entrySet()) {
+ final SequencerCall sequencerCall = entry.getKey();
+ final Set<RepositoryNodePath> outputPaths = entry.getValue();
+ final Sequencer sequencer = sequencerCall.getSequencer();
+ final String sequencerName = sequencer.getConfiguration().getName();
+ final String propertyName = sequencerCall.getSequencedPropertyName();
+
+ // Get the paths to the nodes where the sequencer should write it's output ...
+ assert outputPaths != null && outputPaths.size() != 0;
+
+ // Create a new execution context for each sequencer
+ final Context executionContext = new Context();
+ final ProgressMonitor sequenceMonitor = progressMonitor.createSubtask(1);
+ try {
+ sequenceMonitor.beginTask(100, RepositoryI18n.sequencerSubtask, sequencerName);
+ sequencer.execute(node, propertyName, changedNode, outputPaths, executionContext, sequenceMonitor.createSubtask(80)); // 80%
+ } catch (RepositoryException e) {
+ this.logger.error(e, RepositoryI18n.errorInRepositoryWhileSequencingNode, sequencerName, changedNode);
+ } catch (SequencerException e) {
+ this.logger.error(e, RepositoryI18n.errorWhileSequencingNode, sequencerName, changedNode);
+ } finally {
+ try {
+ // Save the changes made by each sequencer ...
+ if (session != null) session.save();
+ sequenceMonitor.worked(10); // 90% of sequenceMonitor
+ } finally {
+ try {
+ // And always close the context.
+ // This closes all sessions that may have been created by the sequencer.
+ executionContext.close();
+ } finally {
+ sequenceMonitor.done(); // 100% of sequenceMonitor
+ }
+ }
+ }
+ }
+ this.statistics.recordNodeSequenced();
+ } finally {
+ progressMonitor.done();
+ }
+ }
+ } finally {
+ if (session != null) session.logout();
+ }
+ } catch (RepositoryException e) {
+ this.logger.error(e, RepositoryI18n.errorInRepositoryWhileFindingSequencersToRunAgainstNode, changedNode);
+ } catch (Exception e) {
+ this.logger.error(e, RepositoryI18n.errorFindingSequencersToRunAgainstNode, changedNode);
+ }
+ }
+
+ protected class Context implements ExecutionContext {
+
+ protected final SessionFactory factory;
+ private final Set<Session> sessions = new HashSet<Session>();
+ protected final AtomicBoolean closed = new AtomicBoolean(false);
+
+ protected Context() {
+ final SessionFactory delegate = SequencingService.this.getExecutionContext().getSessionFactory();
+ this.factory = new SessionFactory() {
+
+ public Session createSession( String name ) throws RepositoryException {
+ if (closed.get()) throw new IllegalStateException(RepositoryI18n.executionContextHasBeenClosed.text());
+ Session session = delegate.createSession(name);
+ recordSession(session);
+ return session;
+ }
+ };
+ }
+
+ protected synchronized void recordSession( Session session ) {
+ if (session != null) sessions.add(session);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public SessionFactory getSessionFactory() {
+ return this.factory;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public JcrTools getTools() {
+ return SequencingService.this.getExecutionContext().getTools();
+ }
+
+ public synchronized void close() {
+ if (this.closed.get()) return;
+ this.closed.set(true);
+ for (Session session : sessions) {
+ if (session != null) session.logout();
+ }
+ }
+ }
+
+ /**
+ * The statistics for the system. Each sequencing system has an instance of this class that is updated.
+ * @author Randall Hauch
+ */
+ @ThreadSafe
+ public class Statistics {
+
+ private final AtomicLong numberOfNodesSequenced = new AtomicLong(0);
+ private final AtomicLong numberOfNodesSkipped = new AtomicLong(0);
+ private final AtomicLong startTime;
+
+ protected Statistics() {
+ startTime = new AtomicLong(System.currentTimeMillis());
+ }
+
+ public Statistics reset() {
+ this.startTime.set(System.currentTimeMillis());
+ this.numberOfNodesSequenced.set(0);
+ this.numberOfNodesSkipped.set(0);
+ return this;
+ }
+
+ /**
+ * @return the system time when the statistics were started
+ */
+ public long getStartTime() {
+ return this.startTime.get();
+ }
+
+ /**
+ * @return the number of nodes that were sequenced
+ */
+ public long getNumberOfNodesSequenced() {
+ return this.numberOfNodesSequenced.get();
+ }
+
+ /**
+ * @return the number of nodes that were skipped because no sequencers applied
+ */
+ public long getNumberOfNodesSkipped() {
+ return this.numberOfNodesSkipped.get();
+ }
+
+ protected void recordNodeSequenced() {
+ this.numberOfNodesSequenced.incrementAndGet();
+ }
+
+ protected void recordNodeSkipped() {
+ this.numberOfNodesSkipped.incrementAndGet();
+ }
+ }
+
+ @Immutable
+ protected class SequencerCall {
+
+ private final Sequencer sequencer;
+ private final String sequencerName;
+ private final String sequencedPropertyName;
+ private final int hc;
+
+ protected SequencerCall( Sequencer sequencer, String sequencedPropertyName ) {
+ this.sequencer = sequencer;
+ this.sequencerName = sequencer.getConfiguration().getName();
+ this.sequencedPropertyName = sequencedPropertyName;
+ this.hc = HashCode.compute(this.sequencerName, this.sequencedPropertyName);
+ }
+
+ /**
+ * @return sequencer
+ */
+ public Sequencer getSequencer() {
+ return this.sequencer;
+ }
+
+ /**
+ * @return sequencedPropertyName
+ */
+ public String getSequencedPropertyName() {
+ return this.sequencedPropertyName;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int hashCode() {
+ return this.hc;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals( Object obj ) {
+ if (obj == this) return true;
+ if (obj instanceof SequencerCall) {
+ SequencerCall that = (SequencerCall)obj;
+ if (!this.sequencerName.equals(that.sequencerName)) return false;
+ if (!this.sequencedPropertyName.equals(that.sequencedPropertyName)) return false;
+ return true;
+ }
+ return false;
+ }
+ }
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/StreamSequencerAdapter.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/StreamSequencerAdapter.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/sequencers/StreamSequencerAdapter.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,253 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.sequencers;
+
+import java.io.InputStream;
+import java.util.Calendar;
+import java.util.Set;
+import javax.jcr.Node;
+import javax.jcr.PathNotFoundException;
+import javax.jcr.Property;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import org.jboss.dna.common.jcr.Path;
+import org.jboss.dna.common.monitor.ProgressMonitor;
+import org.jboss.dna.common.util.Logger;
+import org.jboss.dna.repository.RepositoryI18n;
+import org.jboss.dna.repository.observation.NodeChange;
+import org.jboss.dna.repository.util.ExecutionContext;
+import org.jboss.dna.repository.util.RepositoryNodePath;
+import org.jboss.dna.spi.sequencers.StreamSequencer;
+
+/**
+ * An adapter class that wraps a {@link StreamSequencer} instance to be a {@link Sequencer}.
+ * @author Randall Hauch
+ */
+public class StreamSequencerAdapter implements Sequencer {
+
+ private SequencerConfig configuration;
+ private final StreamSequencer streamSequencer;
+
+ public StreamSequencerAdapter( StreamSequencer streamSequencer ) {
+ this.streamSequencer = streamSequencer;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public SequencerConfig getConfiguration() {
+ return this.configuration;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void setConfiguration( SequencerConfig configuration ) {
+ this.configuration = configuration;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void execute( Node input, String sequencedPropertyName, NodeChange changes, Set<RepositoryNodePath> outputPaths, ExecutionContext context, ProgressMonitor progressMonitor )
+ throws RepositoryException, SequencerException {
+ // 'sequencedPropertyName' contains the name of the modified property on 'input' that resuled the call to this sequencer
+ // 'changes' contains all of the changes to this node that occurred in the transaction.
+ // 'outputPaths' contains the paths of the node(s) where this sequencer is to save it's data
+
+ try {
+ progressMonitor.beginTask(100, RepositoryI18n.sequencingPropertyOnNode, sequencedPropertyName, input.getPath());
+
+ // Get the property that contains the image data, given by 'propertyName' ...
+ Property imageDataProperty = null;
+ try {
+ imageDataProperty = input.getProperty(sequencedPropertyName);
+ } catch (PathNotFoundException e) {
+ String msg = RepositoryI18n.unableToFindPropertyForSequencing.text(sequencedPropertyName, input.getPath());
+ throw new SequencerException(msg, e);
+ }
+ progressMonitor.worked(10);
+
+ // Get the binary property with the image content, and build the image metadata from the image ...
+ SequencerOutputMap output = new SequencerOutputMap();
+ InputStream stream = null;
+ Throwable firstError = null;
+ ProgressMonitor sequencingMonitor = progressMonitor.createSubtask(50);
+ try {
+ stream = imageDataProperty.getStream();
+ this.streamSequencer.sequence(stream, output, sequencingMonitor);
+ } catch (Throwable t) {
+ // Record the error ...
+ firstError = t;
+ } finally {
+ sequencingMonitor.done();
+ if (stream != null) {
+ // Always close the stream, recording the error if we've not yet seen an error
+ try {
+ stream.close();
+ } catch (Throwable t) {
+ if (firstError == null) firstError = t;
+ } finally {
+ stream = null;
+ }
+ }
+ if (firstError != null) {
+ // Wrap and throw the first error that we saw ...
+ throw new SequencerException(firstError);
+ }
+ }
+
+ // Find each output node and save the image metadata there ...
+ ProgressMonitor writingProgress = progressMonitor.createSubtask(40);
+ writingProgress.beginTask(outputPaths.size(), RepositoryI18n.writingOutputSequencedFromPropertyOnNodes, sequencedPropertyName, input.getPath(), outputPaths.size());
+ for (RepositoryNodePath outputPath : outputPaths) {
+ Session session = null;
+ try {
+ // Get the name of the repository workspace and the path to the output node
+ final String repositoryWorkspaceName = outputPath.getRepositoryWorkspaceName();
+ final String nodePath = outputPath.getNodePath();
+
+ // Create a session to the repository where the data should be written ...
+ session = context.getSessionFactory().createSession(repositoryWorkspaceName);
+
+ // Find or create the output node in this session ...
+ Node outputNode = context.getTools().findOrCreateNode(session, nodePath);
+
+ // Now save the image metadata to the output node ...
+ if (saveOutput(outputNode, output, context)) {
+ session.save();
+ }
+ } finally {
+ writingProgress.worked(1);
+ // Always close the session ...
+ if (session != null) session.logout();
+ }
+ }
+ writingProgress.done();
+ } finally {
+ progressMonitor.done();
+ }
+ }
+
+ /**
+ * Save the sequencing output to the supplied node. This method does not need to save the output, as that is done by the
+ * caller of this method.
+ * @param outputNode the existing node onto (or below) which the output is to be written; never null
+ * @param outputProperties the (immutable) sequencing output; never null
+ * @param context the execution context for this sequencing operation; never null
+ * @return true if the output was written to the node, or false if no information was written
+ * @throws RepositoryException
+ */
+ protected boolean saveOutput( Node outputNode, SequencerOutputMap output, ExecutionContext context ) throws RepositoryException {
+ if (output.isEmpty()) return false;
+ final Path outputNodePath = new Path(outputNode.getPath());
+
+ // Iterate over the entries in the output, in Path's natural order (shorter paths first and in lexicographical order by
+ // prefix and name)
+ for (SequencerOutputMap.Entry entry : output) {
+ Path targetNodePath = entry.getPath();
+ String primaryType = entry.getPrimaryTypeValue();
+
+ // Resolve this path relative to the output node path, handling any parent or self references ...
+ Path absolutePath = targetNodePath.isAbsolute() ? targetNodePath : outputNodePath.resolve(targetNodePath);
+ Path relativePath = absolutePath.relativeTo(outputNodePath);
+
+ // Find or add the node (which may involve adding intermediate nodes) ...
+ Node targetNode = outputNode;
+ for (int i = 0, max = relativePath.size(); i != max; ++i) {
+ Path.Segment segment = relativePath.getSegment(i);
+ String qualifiedName = segment.getQualifiedName(true);
+ if (targetNode.hasNode(qualifiedName)) {
+ targetNode = targetNode.getNode(qualifiedName);
+ } else {
+ // It doesn't exist, so create it ...
+ if (segment.hasIndex()) {
+ // Use a name without an index ...
+ qualifiedName = segment.getQualifiedName(false);
+ }
+ // We only have the primary type for the final one ...
+ if (i == (max - 1) && primaryType != null) {
+ targetNode = targetNode.addNode(qualifiedName, primaryType);
+ } else {
+ targetNode = targetNode.addNode(qualifiedName);
+ }
+ }
+ assert targetNode != null;
+ }
+ assert targetNode != null;
+
+ // Set all of the properties on this
+ for (SequencerOutputMap.PropertyValue property : entry.getPropertyValues()) {
+ String propertyName = property.getName();
+ Object value = property.getValue();
+ Logger.getLogger(this.getClass()).trace("Writing property {0}/{1}={2}", targetNode.getPath(), propertyName, value);
+ if (value instanceof Boolean) {
+ targetNode.setProperty(propertyName, ((Boolean)value).booleanValue());
+ } else if (value instanceof String) {
+ targetNode.setProperty(propertyName, (String)value);
+ } else if (value instanceof Integer) {
+ targetNode.setProperty(propertyName, ((Integer)value).intValue());
+ } else if (value instanceof Short) {
+ targetNode.setProperty(propertyName, ((Short)value).shortValue());
+ } else if (value instanceof Long) {
+ targetNode.setProperty(propertyName, ((Long)value).longValue());
+ } else if (value instanceof Float) {
+ targetNode.setProperty(propertyName, ((Float)value).floatValue());
+ } else if (value instanceof Double) {
+ targetNode.setProperty(propertyName, ((Double)value).doubleValue());
+ } else if (value instanceof Calendar) {
+ targetNode.setProperty(propertyName, (Calendar)value);
+ } else if (value instanceof Path) {
+ // Find the path to reference node ...
+ Path pathToReferencedNode = (Path)value;
+ if (!pathToReferencedNode.isAbsolute()) {
+ // Resolve the path relative to the output node ...
+ pathToReferencedNode = outputNodePath.resolve(pathToReferencedNode);
+ }
+ // Find the referenced node ...
+ try {
+ Node referencedNode = outputNode.getNode(pathToReferencedNode.getString());
+ targetNode.setProperty(propertyName, referencedNode);
+ } catch (PathNotFoundException e) {
+ String msg = RepositoryI18n.errorGettingNodeRelativeToNode.text(value, outputNode.getPath());
+ throw new SequencerException(msg, e);
+ }
+ } else if (value == null) {
+ // Remove the property ...
+ targetNode.setProperty(propertyName, (String)null);
+ } else {
+ String msg = RepositoryI18n.unknownPropertyValueType.text(value, value.getClass().getName());
+ throw new SequencerException(msg);
+ }
+ }
+ }
+
+ return true;
+ }
+
+ protected String[] extractMixinTypes( Object value ) {
+ if (value instanceof String[]) return (String[])value;
+ if (value instanceof String) return new String[] {(String)value};
+ return null;
+ }
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/AbstractServiceAdministrator.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/AbstractServiceAdministrator.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/AbstractServiceAdministrator.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,216 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.services;
+
+import org.jboss.dna.repository.RepositoryI18n;
+import net.jcip.annotations.GuardedBy;
+import net.jcip.annotations.ThreadSafe;
+
+/**
+ * Simple abstract implementation of the service administrator interface that can be easily subclassed by services that require an
+ * administrative interface.
+ * @author Randall Hauch
+ */
+ at ThreadSafe
+public abstract class AbstractServiceAdministrator implements ServiceAdministrator {
+
+ private volatile State state;
+
+ protected AbstractServiceAdministrator( State initialState ) {
+ assert initialState != null;
+ this.state = initialState;
+ }
+
+ /**
+ * Return the current state of this service.
+ * @return the current state
+ */
+ public State getState() {
+ return this.state;
+ }
+
+ /**
+ * Set the state of the service. This method does nothing if the desired state matches the current state.
+ * @param state the desired state
+ * @return this object for method chaining purposes
+ * @see #setState(String)
+ * @see #start()
+ * @see #pause()
+ * @see #shutdown()
+ */
+ @GuardedBy( "this" )
+ public synchronized ServiceAdministrator setState( State state ) {
+ switch (state) {
+ case STARTED:
+ start();
+ break;
+ case PAUSED:
+ pause();
+ break;
+ case SHUTDOWN:
+ shutdown();
+ break;
+ }
+ return this;
+ }
+
+ /**
+ * Set the state of the service. This method does nothing if the desired state matches the current state.
+ * @param state the desired state in string form
+ * @return this object for method chaining purposes
+ * @throws IllegalArgumentException if the specified state string is null or does not match one of the predefined
+ * {@link ServiceAdministrator.State predefined enumerated values}
+ * @see #setState(State)
+ * @see #start()
+ * @see #pause()
+ * @see #shutdown()
+ */
+ public ServiceAdministrator setState( String state ) {
+ State newState = state == null ? null : State.valueOf(state.toUpperCase());
+ if (newState == null) {
+ throw new IllegalArgumentException(RepositoryI18n.invalidStateString.text(state));
+ }
+ return setState(newState);
+ }
+
+ /**
+ * Start monitoring and sequence the events. This method can be called multiple times, including after the service is
+ * {@link #pause() paused}. However, once the service is {@link #shutdown() shutdown}, it cannot be started or paused.
+ * @return this object for method chaining purposes
+ * @throws IllegalStateException if called when the service has been {@link #shutdown() shutdown}.
+ * @see #pause()
+ * @see #shutdown()
+ * @see #isStarted()
+ */
+ public synchronized ServiceAdministrator start() {
+ if (isShutdown()) throw new IllegalStateException(RepositoryI18n.serviceShutdowAndMayNotBeStarted.text(serviceName()));
+ if (this.state != State.STARTED) {
+ doStart(this.state);
+ this.state = State.STARTED;
+ }
+ return this;
+ }
+
+ /**
+ * Implementation of the functionality to switch to the started state. This method is only called if the state from which the
+ * service is transitioning is appropriate ({@link State#PAUSED}). This method does nothing by default, and should be
+ * overridden if needed.
+ * @param fromState the state from which this service is transitioning; never null
+ * @throws IllegalStateException if the service is such that it cannot be transitioned from the supplied state
+ */
+ @GuardedBy( "this" )
+ protected void doStart( State fromState ) {
+ }
+
+ /**
+ * Temporarily stop monitoring and sequencing events. This method can be called multiple times, including after the service is
+ * {@link #start() started}. However, once the service is {@link #shutdown() shutdown}, it cannot be started or paused.
+ * @return this object for method chaining purposes
+ * @throws IllegalStateException if called when the service has been {@link #shutdown() shutdown}.
+ * @see #start()
+ * @see #shutdown()
+ * @see #isPaused()
+ */
+ public synchronized ServiceAdministrator pause() {
+ if (isShutdown()) throw new IllegalStateException(RepositoryI18n.serviceShutdowAndMayNotBePaused.text(serviceName()));
+ if (this.state != State.PAUSED) {
+ doPause(this.state);
+ this.state = State.PAUSED;
+ }
+ return this;
+ }
+
+ /**
+ * Implementation of the functionality to switch to the paused state. This method is only called if the state from which the
+ * service is transitioning is appropriate ({@link State#STARTED}). This method does nothing by default, and should be
+ * overridden if needed.
+ * @param fromState the state from which this service is transitioning; never null
+ * @throws IllegalStateException if the service is such that it cannot be transitioned from the supplied state
+ */
+ @GuardedBy( "this" )
+ protected void doPause( State fromState ) {
+ }
+
+ /**
+ * Permanently stop monitoring and sequencing events. This method can be called multiple times, but only the first call has an
+ * effect. Once the service has been shutdown, it may not be {@link #start() restarted} or {@link #pause() paused}.
+ * @return this object for method chaining purposes
+ * @see #start()
+ * @see #pause()
+ * @see #isShutdown()
+ */
+ public synchronized ServiceAdministrator shutdown() {
+ if (this.state != State.SHUTDOWN) {
+ doShutdown(this.state);
+ this.state = State.SHUTDOWN;
+ }
+ return this;
+ }
+
+ /**
+ * Implementation of the functionality to switch to the shutdown state. This method is only called if the state from which the
+ * service is transitioning is appropriate ({@link State#STARTED} or {@link State#PAUSED}). This method does nothing by
+ * default, and should be overridden if needed.
+ * @param fromState the state from which this service is transitioning; never null
+ * @throws IllegalStateException if the service is such that it cannot be transitioned from the supplied state
+ */
+ @GuardedBy( "this" )
+ protected void doShutdown( State fromState ) {
+ }
+
+ /**
+ * Return whether this service has been started and is currently running.
+ * @return true if started and currently running, or false otherwise
+ * @see #start()
+ * @see #pause()
+ * @see #isPaused()
+ * @see #isShutdown()
+ */
+ public boolean isStarted() {
+ return this.state == State.STARTED;
+ }
+
+ /**
+ * Return whether this service is currently paused.
+ * @return true if currently paused, or false otherwise
+ * @see #pause()
+ * @see #start()
+ * @see #isStarted()
+ * @see #isShutdown()
+ */
+ public boolean isPaused() {
+ return this.state == State.PAUSED;
+ }
+
+ /**
+ * Return whether this service is stopped and unable to be restarted.
+ * @return true if currently shutdown, or false otherwise
+ * @see #shutdown()
+ * @see #isPaused()
+ * @see #isStarted()
+ */
+ public boolean isShutdown() {
+ return this.state == State.SHUTDOWN;
+ }
+
+ protected abstract String serviceName();
+}
Property changes on: trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/AbstractServiceAdministrator.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/AdministeredService.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/AdministeredService.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/AdministeredService.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,30 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.services;
+
+/**
+ * @author Randall Hauch
+ */
+public interface AdministeredService {
+
+ ServiceAdministrator getAdministrator();
+}
Property changes on: trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/AdministeredService.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/ServiceAdministrator.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/ServiceAdministrator.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/ServiceAdministrator.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,144 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.services;
+
+import java.util.concurrent.TimeUnit;
+import net.jcip.annotations.ThreadSafe;
+
+/**
+ * Contract defining an administrative interface for controlling the running state of a service.
+ * @author Randall Hauch
+ */
+ at ThreadSafe
+public interface ServiceAdministrator {
+
+ /**
+ * The available states.
+ * @author Randall Hauch
+ */
+ public static enum State {
+ STARTED,
+ PAUSED,
+ SHUTDOWN;
+ }
+
+ /**
+ * Return the current state of this system.
+ * @return the current state
+ */
+ public State getState();
+
+ /**
+ * Set the state of the system. This method does nothing if the desired state matches the current state.
+ * @param state the desired state
+ * @return this object for method chaining purposes
+ * @see #setState(String)
+ * @see #start()
+ * @see #pause()
+ * @see #shutdown()
+ */
+ public ServiceAdministrator setState( State state );
+
+ /**
+ * Set the state of the system. This method does nothing if the desired state matches the current state.
+ * @param state the desired state in string form
+ * @return this object for method chaining purposes
+ * @throws IllegalArgumentException if the specified state string is null or does not match one of the predefined
+ * {@link State predefined enumerated values}
+ * @see #setState(State)
+ * @see #start()
+ * @see #pause()
+ * @see #shutdown()
+ */
+ public ServiceAdministrator setState( String state );
+
+ /**
+ * Start monitoring and sequence the events. This method can be called multiple times, including after the system is
+ * {@link #pause() paused}. However, once the system is {@link #shutdown() shutdown}, it cannot be started or paused.
+ * @return this object for method chaining purposes
+ * @throws IllegalStateException if called when the system has been {@link #shutdown() shutdown}.
+ * @see #pause()
+ * @see #shutdown()
+ * @see #isStarted()
+ */
+ public ServiceAdministrator start();
+
+ /**
+ * Temporarily stop monitoring and sequencing events. This method can be called multiple times, including after the system is
+ * {@link #start() started}. However, once the system is {@link #shutdown() shutdown}, it cannot be started or paused.
+ * @return this object for method chaining purposes
+ * @throws IllegalStateException if called when the system has been {@link #shutdown() shutdown}.
+ * @see #start()
+ * @see #shutdown()
+ * @see #isPaused()
+ */
+ public ServiceAdministrator pause();
+
+ /**
+ * Permanently stop monitoring and sequencing events. This method can be called multiple times, but only the first call has an
+ * effect. Once the system has been shutdown, it may not be {@link #start() restarted} or {@link #pause() paused}.
+ * @return this object for method chaining purposes
+ * @see #start()
+ * @see #pause()
+ * @see #isShutdown()
+ */
+ public ServiceAdministrator shutdown();
+
+ /**
+ * Blocks until all work has completed execution after a shutdown request, or the timeout occurs, or the current thread is
+ * interrupted, whichever happens first.
+ * @param timeout the maximum time to wait
+ * @param unit the time unit of the timeout argument
+ * @return <tt>true</tt> if this service terminated and <tt>false</tt> if the timeout elapsed before termination
+ * @throws InterruptedException if interrupted while waiting
+ */
+ boolean awaitTermination( long timeout, TimeUnit unit ) throws InterruptedException;
+
+ /**
+ * Return whether this system has been started and is currently running.
+ * @return true if started and currently running, or false otherwise
+ * @see #start()
+ * @see #pause()
+ * @see #isPaused()
+ * @see #isShutdown()
+ */
+ public boolean isStarted();
+
+ /**
+ * Return whether this system is currently paused.
+ * @return true if currently paused, or false otherwise
+ * @see #pause()
+ * @see #start()
+ * @see #isStarted()
+ * @see #isShutdown()
+ */
+ public boolean isPaused();
+
+ /**
+ * Return whether this system is stopped and unable to be restarted.
+ * @return true if currently shutdown, or false otherwise
+ * @see #shutdown()
+ * @see #isPaused()
+ * @see #isStarted()
+ */
+ public boolean isShutdown();
+}
Property changes on: trunk/dna-repository/src/main/java/org/jboss/dna/repository/services/ServiceAdministrator.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/ExecutionContext.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/ExecutionContext.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/ExecutionContext.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,45 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.util;
+
+import javax.jcr.Session;
+
+/**
+ * The context of an execution.
+ * @author Randall Hauch
+ */
+public interface ExecutionContext {
+
+ /**
+ * Get the session factory, which can be used to obtain sessions temporarily for this context. Any session obtained from this
+ * factory should be {@link Session#logout() closed} before the execution finishes.
+ * @return the session factory
+ */
+ SessionFactory getSessionFactory();
+
+ /**
+ * Get a set of utilities for working with JCR.
+ * @return the tools
+ */
+ JcrTools getTools();
+
+}
Property changes on: trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/ExecutionContext.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/JcrTools.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/JcrTools.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/JcrTools.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,300 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
+import javax.jcr.Node;
+import javax.jcr.NodeIterator;
+import javax.jcr.PathNotFoundException;
+import javax.jcr.Property;
+import javax.jcr.PropertyType;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.Value;
+import javax.jcr.ValueFormatException;
+import org.jboss.dna.common.collection.Problem;
+import org.jboss.dna.common.collection.Problems;
+import org.jboss.dna.common.util.IoUtil;
+import org.jboss.dna.common.util.Logger;
+import org.jboss.dna.common.util.StringUtil;
+import org.jboss.dna.repository.RepositoryI18n;
+
+/**
+ * @author Randall Hauch
+ */
+public class JcrTools {
+
+ public Map<String, Object> loadProperties( Node propertyContainer, Problems problems ) {
+ return loadProperties(propertyContainer, null, problems);
+ }
+
+ public Map<String, Object> loadProperties( Node propertyContainer, Map<String, Object> properties, Problems problems ) {
+ if (properties == null) properties = new HashMap<String, Object>();
+ if (propertyContainer != null) {
+ try {
+ NodeIterator iter = propertyContainer.getNodes();
+ while (iter.hasNext()) {
+ Node propertyNode = iter.nextNode();
+ if (propertyNode != null && propertyNode.getPrimaryNodeType().isNodeType("dna:property")) {
+ String propertyName = propertyNode.getName();
+ Object propertyValue = getPropertyValue(propertyNode, "dna:propertyValue", true, problems);
+ properties.put(propertyName, propertyValue);
+ }
+ }
+ } catch (RepositoryException e) {
+ problems.addError(e, RepositoryI18n.errorReadingPropertiesFromContainerNode, getReadable(propertyContainer));
+ }
+ }
+
+ return properties;
+ }
+
+ public boolean removeProblems( Node parent ) throws RepositoryException {
+ Node problemsNode = null;
+ if (parent.hasNode("dna:problems")) {
+ problemsNode = parent.getNode("dna:problems");
+ problemsNode.remove();
+ return true;
+ }
+ return false;
+ }
+
+ public boolean storeProblems( Node parent, Problems problems ) throws RepositoryException {
+ Node problemsNode = null;
+ if (parent.hasNode("dna:problems")) {
+ problemsNode = parent.getNode("dna:problems");
+ // Delete all problems ...
+ removeAllChildren(problemsNode);
+ }
+ if (problems.isEmpty()) {
+ return false;
+ }
+ if (problemsNode == null) {
+ problemsNode = parent.addNode("dna:problems"); // primary type dictated by child definition
+ }
+
+ // Add a child for each problem ...
+ for (Problem problem : problems) {
+ Node problemNode = problemsNode.addNode("problem", "dna:problem");
+ // - dna:status (string) mandatory copy
+ // < 'ERROR', 'WARNING', 'INFO'
+ // - dna:message (string) mandatory copy
+ // - dna:code (string) copy
+ // - dna:type (string) copy
+ // - dna:resource (string) copy
+ // - dna:location (string) copy
+ // - dna:trace (string) copy
+ problemNode.setProperty("dna:status", problem.getStatus().name());
+ problemNode.setProperty("dna:message", problem.getMessageString());
+ if (problem.getCode() != Problem.DEFAULT_CODE) {
+ problemNode.setProperty("dna:code", Integer.toString(problem.getCode()));
+ }
+ String resource = problem.getResource();
+ if (resource != null) {
+ problemNode.setProperty("dna:resource", resource);
+ }
+ String location = problem.getLocation();
+ if (location != null) {
+ problemNode.setProperty("dna:location", location);
+ }
+ Throwable t = problem.getThrowable();
+ if (t != null) {
+ String trace = StringUtil.getStackTrace(t);
+ problemNode.setProperty("dna:trace", trace);
+ }
+ }
+ return true;
+ }
+
+ public int removeAllChildren( Node node ) throws RepositoryException {
+ int childrenRemoved = 0;
+ NodeIterator iter = node.getNodes();
+ while (iter.hasNext()) {
+ Node child = iter.nextNode();
+ child.remove();
+ ++childrenRemoved;
+ }
+ return childrenRemoved;
+ }
+
+ public String getPropertyAsString( Node node, String propertyName, boolean required, Problems problems ) {
+ return getPropertyAsString(node, propertyName, required, null);
+ }
+
+ public String getPropertyAsString( Node node, String propertyName, boolean required, String defaultValue, Problems problems ) {
+ try {
+ Property property = node.getProperty(propertyName);
+ return property.getString();
+ } catch (ValueFormatException e) {
+ if (required) {
+ problems.addError(e, RepositoryI18n.requiredPropertyOnNodeWasExpectedToBeStringValue, propertyName, getReadable(node));
+ } else {
+ problems.addError(e, RepositoryI18n.optionalPropertyOnNodeWasExpectedToBeStringValue, propertyName, getReadable(node));
+ }
+ } catch (PathNotFoundException e) {
+ if (required) {
+ problems.addError(e, RepositoryI18n.requiredPropertyIsMissingFromNode, propertyName, getReadable(node));
+ }
+ if (!required) return defaultValue;
+ } catch (RepositoryException err) {
+ if (required) {
+ problems.addError(err, RepositoryI18n.errorGettingRequiredPropertyFromNode, propertyName, getReadable(node));
+ } else {
+ problems.addError(err, RepositoryI18n.errorGettingOptionalPropertyFromNode, propertyName, getReadable(node));
+ }
+ }
+ return null;
+ }
+
+ public Object getPropertyValue( Node node, String propertyName, boolean required, Problems problems ) {
+ try {
+ Property property = node.getProperty(propertyName);
+ switch (property.getType()) {
+ case PropertyType.BINARY: {
+ InputStream stream = property.getStream();
+ try {
+ stream = property.getStream();
+ return IoUtil.readBytes(stream);
+ } finally {
+ if (stream != null) {
+ try {
+ stream.close();
+ } catch (IOException e) {
+ // Log ...
+ Logger.getLogger(this.getClass()).error(e, RepositoryI18n.errorClosingBinaryStreamForPropertyFromNode, propertyName, node.getPath());
+ }
+ }
+ }
+ }
+ default: {
+ return property.getString();
+ }
+ }
+ } catch (IOException e) {
+ if (required) {
+ problems.addError(e, RepositoryI18n.requiredPropertyOnNodeCouldNotBeRead, propertyName, getReadable(node));
+ } else {
+ problems.addError(e, RepositoryI18n.optionalPropertyOnNodeCouldNotBeRead, propertyName, getReadable(node));
+ }
+ } catch (PathNotFoundException e) {
+ if (required) {
+ problems.addError(e, RepositoryI18n.requiredPropertyIsMissingFromNode, propertyName, getReadable(node));
+ }
+ } catch (RepositoryException err) {
+ if (required) {
+ problems.addError(err, RepositoryI18n.errorGettingRequiredPropertyFromNode, propertyName, getReadable(node));
+ } else {
+ problems.addError(err, RepositoryI18n.errorGettingOptionalPropertyFromNode, propertyName, getReadable(node));
+ }
+ }
+ return null;
+ }
+
+ public String[] getPropertyAsStringArray( Node node, String propertyName, boolean required, Problems problems, String... defaultValues ) {
+ String[] result = defaultValues;
+ try {
+ Property property = node.getProperty(propertyName);
+ if (property.getDefinition().isMultiple()) {
+ Value[] values = property.getValues();
+ result = new String[values.length];
+ int i = 0;
+ for (Value value : values) {
+ result[i++] = value.getString();
+ }
+ } else {
+ result = new String[] {property.getString()};
+ }
+ } catch (ValueFormatException e) {
+ if (required) {
+ problems.addError(e, RepositoryI18n.requiredPropertyOnNodeWasExpectedToBeStringArrayValue, propertyName, getReadable(node));
+ } else {
+ problems.addError(e, RepositoryI18n.optionalPropertyOnNodeWasExpectedToBeStringArrayValue, propertyName, getReadable(node));
+ }
+ } catch (PathNotFoundException e) {
+ if (required) {
+ problems.addError(e, RepositoryI18n.requiredPropertyIsMissingFromNode, propertyName, getReadable(node));
+ }
+ } catch (RepositoryException err) {
+ if (required) {
+ problems.addError(err, RepositoryI18n.errorGettingRequiredPropertyFromNode, propertyName, getReadable(node));
+ } else {
+ problems.addError(err, RepositoryI18n.errorGettingOptionalPropertyFromNode, propertyName, getReadable(node));
+ }
+ }
+ return result;
+ }
+
+ public Node getNode( Node node, String relativePath, boolean required, Problems problems ) {
+ Node result = null;
+ try {
+ result = node.getNode(relativePath);
+ } catch (PathNotFoundException e) {
+ if (required) problems.addError(e, RepositoryI18n.requiredNodeDoesNotExistRelativeToNode, relativePath, getReadable(node));
+ } catch (RepositoryException err) {
+ problems.addError(err, RepositoryI18n.errorGettingNodeRelativeToNode, relativePath, getReadable(node));
+ }
+ return result;
+ }
+
+ public String getReadable( Node node ) {
+ if (node == null) return "";
+ try {
+ return node.getPath();
+ } catch (RepositoryException err) {
+ return node.toString();
+ }
+ }
+
+ public Node findOrCreateNode( Session session, String path ) throws RepositoryException {
+ Node root = session.getRootNode();
+ // Remove leading and trailing slashes ...
+ String relPath = path.replaceAll("^/+", "").replaceAll("/+$", "");
+
+ // Look for the node first ...
+ try {
+ return root.getNode(relPath);
+ } catch (PathNotFoundException e) {
+ // continue
+ }
+ // Create the node, which has to be done segment by segment ...
+ String[] pathSegments = relPath.split("/");
+ Node node = root;
+ for (String pathSegment : pathSegments) {
+ pathSegment = pathSegment.trim();
+ if (pathSegment.length() == 0) continue;
+ if (node.hasNode(pathSegment)) {
+ // Find the existing node ...
+ node = node.getNode(pathSegment);
+ } else {
+ // Make sure there is no index on the final segment ...
+ String pathSegmentWithNoIndex = pathSegment.replaceAll("(\\[\\d+\\])+$", "");
+ // Create the node ...
+ node = node.addNode(pathSegmentWithNoIndex);
+ }
+ }
+ return node;
+ }
+
+}
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/JndiSessionFactory.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/JndiSessionFactory.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/JndiSessionFactory.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,249 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.jboss.dna.repository.util;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import javax.jcr.Credentials;
+import javax.jcr.Repository;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.SimpleCredentials;
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import org.jboss.dna.common.SystemFailureException;
+import org.jboss.dna.common.util.ArgCheck;
+import org.jboss.dna.repository.RepositoryI18n;
+
+/**
+ * A SessionFactory implementation that creates {@link Session} instances using {@link Repository} instances registered in JNDI.
+ * <p>
+ * This factory using a naming convention where the name supplied to the {@link #createSession(String)} contains both the name of
+ * the repository and the name of the workspace. Typically, this is <i><code>repositoryName/workspaceName</code></i>, where
+ * <code>repositoryName</code> is the JNDI name under which the Repository instance was bound, and <code>workspaceName</code>
+ * is the name of the workspace. Note that this method looks for the last delimiter in the whole name to distinguish between the
+ * repository and workspace names.
+ * </p>
+ * <p>
+ * For example, if "<code>java:comp/env/repository/dataRepository/myWorkspace</code>" is passed to the
+ * {@link #createSession(String)} method, this factory will look for a {@link Repository} instance registered in JDNI with the
+ * name "<code>java:comp/env/repository/dataRepository</code>" and use it to {@link Repository#login(String) create a session}
+ * to the workspace named "<code>myWorkspace</code>".
+ * </p>
+ * <p>
+ * By default, this factory creates an anonymous JCR session. To use sessions with specific {@link Credentials}, simply
+ * {@link #registerCredentials(String, Credentials) register} credentials for the appropriate repository/workspace name. For
+ * security reasons, it is not possible to retrieve the Credentials once registered with this factory.
+ * </p>
+ * @author Randall Hauch
+ */
+public class JndiSessionFactory implements SessionFactory {
+
+ protected static char[] DEFAULT_DELIMITERS = new char[] {'/'};
+
+ private final char[] workspaceDelims;
+ private final String workspaceDelimsRegexCharacterSet;
+ private final Context context;
+ private final Map<String, Credentials> credentials = new ConcurrentHashMap<String, Credentials>();
+
+ /**
+ * Create an instance of the factory by creating a new {@link InitialContext}. This is equivalent to calling
+ * <code>new JndiSessionFactory(new InitialContext())</code>.
+ * @throws NamingException if there is a problem creating the InitialContext.
+ */
+ public JndiSessionFactory() throws NamingException {
+ this(new InitialContext());
+ }
+
+ /**
+ * Create an instance of the factory by supplying the characters that may be used to delimit the workspace name from the
+ * repository name. This constructor initializes the factory with a new {@link InitialContext}, and is equivalent to calling
+ * <code>new JndiSessionFactory(new InitialContext(),workspaceDelimiters)</code>.
+ * @param workspaceDelimiters the delimiters, or null/empty if the default delimiter of '/' should be used.
+ * @throws NamingException if there is a problem creating the InitialContext.
+ */
+ public JndiSessionFactory( char... workspaceDelimiters ) throws NamingException {
+ this(new InitialContext(), workspaceDelimiters);
+ }
+
+ /**
+ * Create an instance of the factory using the supplied JNDI context.
+ * @param context the naming context
+ * @throws IllegalArgumentException if the context parameter is null
+ */
+ public JndiSessionFactory( Context context ) {
+ this(context, DEFAULT_DELIMITERS);
+ }
+
+ /**
+ * Create an instance of the factory by supplying naming context and the characters that may be used to delimit the workspace
+ * name from the repository name.
+ * @param context the naming context
+ * @param workspaceDelimiters the delimiters, or null/empty if the default delimiter of '/' should be used.
+ * @throws IllegalArgumentException if the context parameter is null
+ */
+ public JndiSessionFactory( Context context, char... workspaceDelimiters ) {
+ ArgCheck.isNotNull(context, "initial context");
+ this.context = context;
+ this.workspaceDelims = (workspaceDelimiters == null || workspaceDelimiters.length == 0) ? DEFAULT_DELIMITERS : workspaceDelimiters;
+ StringBuilder sb = new StringBuilder();
+ for (char delim : this.workspaceDelims) {
+ switch (delim) {
+ case '\\':
+ sb.append("\\");
+ break;
+ // case '[' : sb.append("\\["); break;
+ case ']':
+ sb.append("\\]");
+ break;
+ case '-':
+ sb.append("\\-");
+ break;
+ case '^':
+ sb.append("\\^");
+ break;
+ default:
+ sb.append(delim);
+ }
+ }
+ this.workspaceDelimsRegexCharacterSet = sb.toString();
+ }
+
+ /**
+ * Convenience method to bind a repository in JNDI. Repository instances can be bound into JNDI using any technique, so this
+ * method need not be used. <i>Note that the name should not contain the workspace part.</i>
+ * @param name the name of the repository, without the workspace name component.
+ * @param repository the repository to be bound, or null if an existing repository should be unbound.
+ * @throws NamingException if there is a problem registering the supplied repository
+ */
+ public void registerRepository( String name, Repository repository ) throws NamingException {
+ assert name != null;
+ // Remove all trailing delimiters ...
+ name = name.replaceAll("[" + this.workspaceDelimsRegexCharacterSet + "]+$", "");
+ if (repository != null) {
+ this.context.bind(name, repository);
+ } else {
+ this.context.unbind(name);
+ }
+ }
+
+ /**
+ * Register the credentials for the repository and workspace given by the supplied name, username and password. This is
+ * equivalent to calling <code>registerCredentials(name, new SimpleCredentials(username,password))</code>, although if
+ * <code>username</code> is null then this is equivalent to <code>registerCredentials(name,null)</code>.
+ * @param name the name of the repository and workspace
+ * @param username the username to use, or null if the existing credentials for the named workspace should be removed
+ * @param password the password, may be null or empty
+ * @return true if this overwrote existing credentials
+ * @see #registerCredentials(String, Credentials)
+ * @see #removeCredentials(String)
+ */
+ public boolean registerCredentials( String name, String username, char[] password ) {
+ if (password == null && username != null) password = new char[] {};
+ Credentials creds = username == null ? null : new SimpleCredentials(username, password);
+ return registerCredentials(name, creds);
+ }
+
+ /**
+ * Register the credentials to be used for the named repository and workspace. Use the same name as used to
+ * {@link #createSession(String) create sessions}.
+ * @param name the name of the repository and workspace
+ * @param credentials the credentials to use, or null if the existing credentials for the named workspace should be removed
+ * @return true if this overwrote existing credentials
+ * @see #registerCredentials(String, String, char[])
+ * @see #removeCredentials(String)
+ */
+ public boolean registerCredentials( String name, Credentials credentials ) {
+ boolean foundExisting = false;
+ name = name != null ? name.trim() : null;
+ if (credentials == null) {
+ foundExisting = this.credentials.remove(name) != null;
+ } else {
+ foundExisting = this.credentials.put(name, credentials) != null;
+ }
+ return foundExisting;
+ }
+
+ /**
+ * Remove any credentials associated with the named repository and workspace. This is equivalent to calling
+ * <code>registerCredentials(name,null)</code>.
+ * @param name the name of the repository and workspace
+ * @return true if existing credentials were found and removed, or false if no such credentials existed
+ * @see #registerCredentials(String, Credentials)
+ */
+ public boolean removeCredentials( String name ) {
+ return registerCredentials(name, null);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Session createSession( String name ) throws RepositoryException {
+ ArgCheck.isNotNull(name, "session name");
+ name = name.trim();
+ // Look up the Repository object in JNDI ...
+ String repositoryName = getRepositoryName(name);
+ Repository repository = null;
+ try {
+ repository = (Repository)this.context.lookup(repositoryName);
+ } catch (NamingException err) {
+ throw new SystemFailureException(RepositoryI18n.unableToFindRepositoryInJndi.text(repositoryName));
+ }
+
+ // Determine the name of the workspace ...
+ String workspaceName = getWorkspaceName(name);
+
+ // Look up any credentials, which may be null ...
+ Credentials creds = this.credentials.get(name);
+
+ // Create a session to the specified workspace and using the credentials (either or both may be null) ...
+ return repository.login(creds, workspaceName);
+ }
+
+ protected String getWorkspaceName( String name ) {
+ assert name != null;
+ int index = getIndexOfLastWorkspaceDelimiter(name);
+ if (index == -1) return null;
+ if ((index + 1) == name.length()) return null; // delim is the last character
+ return name.substring(index + 1);
+ }
+
+ protected String getRepositoryName( String name ) {
+ assert name != null;
+ int index = getIndexOfLastWorkspaceDelimiter(name);
+ if (index == -1) return name; // no delim
+ if ((index + 1) == name.length()) return name.substring(0, index); // delim as last character
+ return name.substring(0, index);
+ }
+
+ protected int getIndexOfLastWorkspaceDelimiter( String name ) {
+ int index = -1;
+ for (char delim : this.workspaceDelims) {
+ int i = name.lastIndexOf(delim);
+ index = Math.max(index, i);
+ }
+ return index;
+ }
+
+}
Property changes on: trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/JndiSessionFactory.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/RepositoryNodePath.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/RepositoryNodePath.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/RepositoryNodePath.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,105 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.util;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import net.jcip.annotations.Immutable;
+import org.jboss.dna.common.util.HashCode;
+import org.jboss.dna.repository.RepositoryI18n;
+
+/**
+ * @author Randall Hauch
+ */
+ at Immutable
+public class RepositoryNodePath {
+
+ protected static final Pattern PATTERN = Pattern.compile("([^:/]):(/.*)");
+
+ public static RepositoryNodePath parse( String path, String defaultRepositoryWorkspaceName ) {
+ Matcher matcher = PATTERN.matcher(path);
+ if (matcher.matches()) {
+ try {
+ return new RepositoryNodePath(matcher.group(1), matcher.group(2));
+ } catch (Throwable t) {
+ throw new IllegalArgumentException(RepositoryI18n.invalidRepositoryNodePath.text(path, t.getMessage()));
+ }
+ }
+ return new RepositoryNodePath(defaultRepositoryWorkspaceName, path);
+
+ }
+
+ private final String repositoryName;
+ private final String nodePath;
+ private final int hc;
+
+ public RepositoryNodePath( String repositoryName, String nodePath ) {
+ this.repositoryName = repositoryName;
+ this.nodePath = nodePath;
+ this.hc = HashCode.compute(this.repositoryName, this.nodePath);
+ }
+
+ /**
+ * @return nodePath
+ */
+ public String getNodePath() {
+ return this.nodePath;
+ }
+
+ /**
+ * @return repositoryName
+ */
+ public String getRepositoryWorkspaceName() {
+ return this.repositoryName;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int hashCode() {
+ return this.hc;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals( Object obj ) {
+ if (obj == this) return true;
+ if (obj instanceof RepositoryNodePath) {
+ RepositoryNodePath that = (RepositoryNodePath)obj;
+ if (!this.repositoryName.equals(that.repositoryName)) return false;
+ if (!this.nodePath.equals(that.nodePath)) return false;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return this.repositoryName + ":" + this.nodePath;
+ }
+}
Property changes on: trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/RepositoryNodePath.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/SessionFactory.java
===================================================================
--- trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/SessionFactory.java (rev 0)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/repository/util/SessionFactory.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,35 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.jboss.dna.repository.util;
+
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+
+/**
+ * @author Randall Hauch
+ */
+public interface SessionFactory {
+
+ Session createSession( String name ) throws RepositoryException;
+
+}
Deleted: trunk/dna-repository/src/main/java/org/jboss/dna/services/AbstractServiceAdministrator.java
===================================================================
--- trunk/dna-services/src/main/java/org/jboss/dna/services/AbstractServiceAdministrator.java 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/services/AbstractServiceAdministrator.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,215 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source.
- * Copyright 2008, Red Hat Middleware LLC, and individual contributors
- * as indicated by the @author tags. See the copyright.txt file in the
- * distribution for a full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-package org.jboss.dna.services;
-
-import net.jcip.annotations.GuardedBy;
-import net.jcip.annotations.ThreadSafe;
-
-/**
- * Simple abstract implementation of the service administrator interface that can be easily subclassed by services that require an
- * administrative interface.
- * @author Randall Hauch
- */
- at ThreadSafe
-public abstract class AbstractServiceAdministrator implements ServiceAdministrator {
-
- private volatile State state;
-
- protected AbstractServiceAdministrator( State initialState ) {
- assert initialState != null;
- this.state = initialState;
- }
-
- /**
- * Return the current state of this service.
- * @return the current state
- */
- public State getState() {
- return this.state;
- }
-
- /**
- * Set the state of the service. This method does nothing if the desired state matches the current state.
- * @param state the desired state
- * @return this object for method chaining purposes
- * @see #setState(String)
- * @see #start()
- * @see #pause()
- * @see #shutdown()
- */
- @GuardedBy( "this" )
- public synchronized ServiceAdministrator setState( State state ) {
- switch (state) {
- case STARTED:
- start();
- break;
- case PAUSED:
- pause();
- break;
- case SHUTDOWN:
- shutdown();
- break;
- }
- return this;
- }
-
- /**
- * Set the state of the service. This method does nothing if the desired state matches the current state.
- * @param state the desired state in string form
- * @return this object for method chaining purposes
- * @throws IllegalArgumentException if the specified state string is null or does not match one of the predefined
- * {@link ServiceAdministrator.State predefined enumerated values}
- * @see #setState(State)
- * @see #start()
- * @see #pause()
- * @see #shutdown()
- */
- public ServiceAdministrator setState( String state ) {
- State newState = state == null ? null : State.valueOf(state.toUpperCase());
- if (newState == null) {
- throw new IllegalArgumentException(ServicesI18n.invalidStateString.text(state));
- }
- return setState(newState);
- }
-
- /**
- * Start monitoring and sequence the events. This method can be called multiple times, including after the service is
- * {@link #pause() paused}. However, once the service is {@link #shutdown() shutdown}, it cannot be started or paused.
- * @return this object for method chaining purposes
- * @throws IllegalStateException if called when the service has been {@link #shutdown() shutdown}.
- * @see #pause()
- * @see #shutdown()
- * @see #isStarted()
- */
- public synchronized ServiceAdministrator start() {
- if (isShutdown()) throw new IllegalStateException(ServicesI18n.serviceShutdowAndMayNotBeStarted.text(serviceName()));
- if (this.state != State.STARTED) {
- doStart(this.state);
- this.state = State.STARTED;
- }
- return this;
- }
-
- /**
- * Implementation of the functionality to switch to the started state. This method is only called if the state from which the
- * service is transitioning is appropriate ({@link State#PAUSED}). This method does nothing by default, and should be
- * overridden if needed.
- * @param fromState the state from which this service is transitioning; never null
- * @throws IllegalStateException if the service is such that it cannot be transitioned from the supplied state
- */
- @GuardedBy( "this" )
- protected void doStart( State fromState ) {
- }
-
- /**
- * Temporarily stop monitoring and sequencing events. This method can be called multiple times, including after the service is
- * {@link #start() started}. However, once the service is {@link #shutdown() shutdown}, it cannot be started or paused.
- * @return this object for method chaining purposes
- * @throws IllegalStateException if called when the service has been {@link #shutdown() shutdown}.
- * @see #start()
- * @see #shutdown()
- * @see #isPaused()
- */
- public synchronized ServiceAdministrator pause() {
- if (isShutdown()) throw new IllegalStateException(ServicesI18n.serviceShutdowAndMayNotBePaused.text(serviceName()));
- if (this.state != State.PAUSED) {
- doPause(this.state);
- this.state = State.PAUSED;
- }
- return this;
- }
-
- /**
- * Implementation of the functionality to switch to the paused state. This method is only called if the state from which the
- * service is transitioning is appropriate ({@link State#STARTED}). This method does nothing by default, and should be
- * overridden if needed.
- * @param fromState the state from which this service is transitioning; never null
- * @throws IllegalStateException if the service is such that it cannot be transitioned from the supplied state
- */
- @GuardedBy( "this" )
- protected void doPause( State fromState ) {
- }
-
- /**
- * Permanently stop monitoring and sequencing events. This method can be called multiple times, but only the first call has an
- * effect. Once the service has been shutdown, it may not be {@link #start() restarted} or {@link #pause() paused}.
- * @return this object for method chaining purposes
- * @see #start()
- * @see #pause()
- * @see #isShutdown()
- */
- public synchronized ServiceAdministrator shutdown() {
- if (this.state != State.SHUTDOWN) {
- doShutdown(this.state);
- this.state = State.SHUTDOWN;
- }
- return this;
- }
-
- /**
- * Implementation of the functionality to switch to the shutdown state. This method is only called if the state from which the
- * service is transitioning is appropriate ({@link State#STARTED} or {@link State#PAUSED}). This method does nothing by
- * default, and should be overridden if needed.
- * @param fromState the state from which this service is transitioning; never null
- * @throws IllegalStateException if the service is such that it cannot be transitioned from the supplied state
- */
- @GuardedBy( "this" )
- protected void doShutdown( State fromState ) {
- }
-
- /**
- * Return whether this service has been started and is currently running.
- * @return true if started and currently running, or false otherwise
- * @see #start()
- * @see #pause()
- * @see #isPaused()
- * @see #isShutdown()
- */
- public boolean isStarted() {
- return this.state == State.STARTED;
- }
-
- /**
- * Return whether this service is currently paused.
- * @return true if currently paused, or false otherwise
- * @see #pause()
- * @see #start()
- * @see #isStarted()
- * @see #isShutdown()
- */
- public boolean isPaused() {
- return this.state == State.PAUSED;
- }
-
- /**
- * Return whether this service is stopped and unable to be restarted.
- * @return true if currently shutdown, or false otherwise
- * @see #shutdown()
- * @see #isPaused()
- * @see #isStarted()
- */
- public boolean isShutdown() {
- return this.state == State.SHUTDOWN;
- }
-
- protected abstract String serviceName();
-}
Deleted: trunk/dna-repository/src/main/java/org/jboss/dna/services/AdministeredService.java
===================================================================
--- trunk/dna-services/src/main/java/org/jboss/dna/services/AdministeredService.java 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/services/AdministeredService.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,30 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source.
- * Copyright 2008, Red Hat Middleware LLC, and individual contributors
- * as indicated by the @author tags. See the copyright.txt file in the
- * distribution for a full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-package org.jboss.dna.services;
-
-/**
- * @author Randall Hauch
- */
-public interface AdministeredService {
-
- ServiceAdministrator getAdministrator();
-}
Deleted: trunk/dna-repository/src/main/java/org/jboss/dna/services/ExecutionContext.java
===================================================================
--- trunk/dna-services/src/main/java/org/jboss/dna/services/ExecutionContext.java 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/services/ExecutionContext.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,46 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source.
- * Copyright 2008, Red Hat Middleware LLC, and individual contributors
- * as indicated by the @author tags. See the copyright.txt file in the
- * distribution for a full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-package org.jboss.dna.services;
-
-import javax.jcr.Session;
-import org.jboss.dna.services.util.JcrTools;
-
-/**
- * The context of an execution.
- * @author Randall Hauch
- */
-public interface ExecutionContext {
-
- /**
- * Get the session factory, which can be used to obtain sessions temporarily for this context. Any session obtained from this
- * factory should be {@link Session#logout() closed} before the execution finishes.
- * @return the session factory
- */
- SessionFactory getSessionFactory();
-
- /**
- * Get a set of utilities for working with JCR.
- * @return the tools
- */
- JcrTools getTools();
-
-}
Deleted: trunk/dna-repository/src/main/java/org/jboss/dna/services/JndiSessionFactory.java
===================================================================
--- trunk/dna-services/src/main/java/org/jboss/dna/services/JndiSessionFactory.java 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/services/JndiSessionFactory.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,248 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source.
- * Copyright 2008, Red Hat Middleware LLC, and individual contributors
- * as indicated by the @author tags. See the copyright.txt file in the
- * distribution for a full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-
-package org.jboss.dna.services;
-
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import javax.jcr.Credentials;
-import javax.jcr.Repository;
-import javax.jcr.RepositoryException;
-import javax.jcr.Session;
-import javax.jcr.SimpleCredentials;
-import javax.naming.Context;
-import javax.naming.InitialContext;
-import javax.naming.NamingException;
-import org.jboss.dna.common.SystemFailureException;
-import org.jboss.dna.common.util.ArgCheck;
-
-/**
- * A SessionFactory implementation that creates {@link Session} instances using {@link Repository} instances registered in JNDI.
- * <p>
- * This factory using a naming convention where the name supplied to the {@link #createSession(String)} contains both the name of
- * the repository and the name of the workspace. Typically, this is <i><code>repositoryName/workspaceName</code></i>, where
- * <code>repositoryName</code> is the JNDI name under which the Repository instance was bound, and <code>workspaceName</code>
- * is the name of the workspace. Note that this method looks for the last delimiter in the whole name to distinguish between the
- * repository and workspace names.
- * </p>
- * <p>
- * For example, if "<code>java:comp/env/repository/dataRepository/myWorkspace</code>" is passed to the
- * {@link #createSession(String)} method, this factory will look for a {@link Repository} instance registered in JDNI with the
- * name "<code>java:comp/env/repository/dataRepository</code>" and use it to {@link Repository#login(String) create a session}
- * to the workspace named "<code>myWorkspace</code>".
- * </p>
- * <p>
- * By default, this factory creates an anonymous JCR session. To use sessions with specific {@link Credentials}, simply
- * {@link #registerCredentials(String, Credentials) register} credentials for the appropriate repository/workspace name. For
- * security reasons, it is not possible to retrieve the Credentials once registered with this factory.
- * </p>
- * @author Randall Hauch
- */
-public class JndiSessionFactory implements SessionFactory {
-
- protected static char[] DEFAULT_DELIMITERS = new char[] {'/'};
-
- private final char[] workspaceDelims;
- private final String workspaceDelimsRegexCharacterSet;
- private final Context context;
- private final Map<String, Credentials> credentials = new ConcurrentHashMap<String, Credentials>();
-
- /**
- * Create an instance of the factory by creating a new {@link InitialContext}. This is equivalent to calling
- * <code>new JndiSessionFactory(new InitialContext())</code>.
- * @throws NamingException if there is a problem creating the InitialContext.
- */
- public JndiSessionFactory() throws NamingException {
- this(new InitialContext());
- }
-
- /**
- * Create an instance of the factory by supplying the characters that may be used to delimit the workspace name from the
- * repository name. This constructor initializes the factory with a new {@link InitialContext}, and is equivalent to calling
- * <code>new JndiSessionFactory(new InitialContext(),workspaceDelimiters)</code>.
- * @param workspaceDelimiters the delimiters, or null/empty if the default delimiter of '/' should be used.
- * @throws NamingException if there is a problem creating the InitialContext.
- */
- public JndiSessionFactory( char... workspaceDelimiters ) throws NamingException {
- this(new InitialContext(), workspaceDelimiters);
- }
-
- /**
- * Create an instance of the factory using the supplied JNDI context.
- * @param context the naming context
- * @throws IllegalArgumentException if the context parameter is null
- */
- public JndiSessionFactory( Context context ) {
- this(context, DEFAULT_DELIMITERS);
- }
-
- /**
- * Create an instance of the factory by supplying naming context and the characters that may be used to delimit the workspace
- * name from the repository name.
- * @param context the naming context
- * @param workspaceDelimiters the delimiters, or null/empty if the default delimiter of '/' should be used.
- * @throws IllegalArgumentException if the context parameter is null
- */
- public JndiSessionFactory( Context context, char... workspaceDelimiters ) {
- ArgCheck.isNotNull(context, "initial context");
- this.context = context;
- this.workspaceDelims = (workspaceDelimiters == null || workspaceDelimiters.length == 0) ? DEFAULT_DELIMITERS : workspaceDelimiters;
- StringBuilder sb = new StringBuilder();
- for (char delim : this.workspaceDelims) {
- switch (delim) {
- case '\\':
- sb.append("\\");
- break;
- // case '[' : sb.append("\\["); break;
- case ']':
- sb.append("\\]");
- break;
- case '-':
- sb.append("\\-");
- break;
- case '^':
- sb.append("\\^");
- break;
- default:
- sb.append(delim);
- }
- }
- this.workspaceDelimsRegexCharacterSet = sb.toString();
- }
-
- /**
- * Convenience method to bind a repository in JNDI. Repository instances can be bound into JNDI using any technique, so this
- * method need not be used. <i>Note that the name should not contain the workspace part.</i>
- * @param name the name of the repository, without the workspace name component.
- * @param repository the repository to be bound, or null if an existing repository should be unbound.
- * @throws NamingException if there is a problem registering the supplied repository
- */
- public void registerRepository( String name, Repository repository ) throws NamingException {
- assert name != null;
- // Remove all trailing delimiters ...
- name = name.replaceAll("[" + this.workspaceDelimsRegexCharacterSet + "]+$", "");
- if (repository != null) {
- this.context.bind(name, repository);
- } else {
- this.context.unbind(name);
- }
- }
-
- /**
- * Register the credentials for the repository and workspace given by the supplied name, username and password. This is
- * equivalent to calling <code>registerCredentials(name, new SimpleCredentials(username,password))</code>, although if
- * <code>username</code> is null then this is equivalent to <code>registerCredentials(name,null)</code>.
- * @param name the name of the repository and workspace
- * @param username the username to use, or null if the existing credentials for the named workspace should be removed
- * @param password the password, may be null or empty
- * @return true if this overwrote existing credentials
- * @see #registerCredentials(String, Credentials)
- * @see #removeCredentials(String)
- */
- public boolean registerCredentials( String name, String username, char[] password ) {
- if (password == null && username != null) password = new char[] {};
- Credentials creds = username == null ? null : new SimpleCredentials(username, password);
- return registerCredentials(name, creds);
- }
-
- /**
- * Register the credentials to be used for the named repository and workspace. Use the same name as used to
- * {@link #createSession(String) create sessions}.
- * @param name the name of the repository and workspace
- * @param credentials the credentials to use, or null if the existing credentials for the named workspace should be removed
- * @return true if this overwrote existing credentials
- * @see #registerCredentials(String, String, char[])
- * @see #removeCredentials(String)
- */
- public boolean registerCredentials( String name, Credentials credentials ) {
- boolean foundExisting = false;
- name = name != null ? name.trim() : null;
- if (credentials == null) {
- foundExisting = this.credentials.remove(name) != null;
- } else {
- foundExisting = this.credentials.put(name, credentials) != null;
- }
- return foundExisting;
- }
-
- /**
- * Remove any credentials associated with the named repository and workspace. This is equivalent to calling
- * <code>registerCredentials(name,null)</code>.
- * @param name the name of the repository and workspace
- * @return true if existing credentials were found and removed, or false if no such credentials existed
- * @see #registerCredentials(String, Credentials)
- */
- public boolean removeCredentials( String name ) {
- return registerCredentials(name, null);
- }
-
- /**
- * {@inheritDoc}
- */
- public Session createSession( String name ) throws RepositoryException {
- ArgCheck.isNotNull(name, "session name");
- name = name.trim();
- // Look up the Repository object in JNDI ...
- String repositoryName = getRepositoryName(name);
- Repository repository = null;
- try {
- repository = (Repository)this.context.lookup(repositoryName);
- } catch (NamingException err) {
- throw new SystemFailureException(ServicesI18n.unableToFindRepositoryInJndi.text(repositoryName));
- }
-
- // Determine the name of the workspace ...
- String workspaceName = getWorkspaceName(name);
-
- // Look up any credentials, which may be null ...
- Credentials creds = this.credentials.get(name);
-
- // Create a session to the specified workspace and using the credentials (either or both may be null) ...
- return repository.login(creds, workspaceName);
- }
-
- protected String getWorkspaceName( String name ) {
- assert name != null;
- int index = getIndexOfLastWorkspaceDelimiter(name);
- if (index == -1) return null;
- if ((index + 1) == name.length()) return null; // delim is the last character
- return name.substring(index + 1);
- }
-
- protected String getRepositoryName( String name ) {
- assert name != null;
- int index = getIndexOfLastWorkspaceDelimiter(name);
- if (index == -1) return name; // no delim
- if ((index + 1) == name.length()) return name.substring(0, index); // delim as last character
- return name.substring(0, index);
- }
-
- protected int getIndexOfLastWorkspaceDelimiter( String name ) {
- int index = -1;
- for (char delim : this.workspaceDelims) {
- int i = name.lastIndexOf(delim);
- index = Math.max(index, i);
- }
- return index;
- }
-
-}
Deleted: trunk/dna-repository/src/main/java/org/jboss/dna/services/RepositoryNodePath.java
===================================================================
--- trunk/dna-services/src/main/java/org/jboss/dna/services/RepositoryNodePath.java 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/services/RepositoryNodePath.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,104 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source.
- * Copyright 2008, Red Hat Middleware LLC, and individual contributors
- * as indicated by the @author tags. See the copyright.txt file in the
- * distribution for a full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-package org.jboss.dna.services;
-
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.util.HashCode;
-
-/**
- * @author Randall Hauch
- */
- at Immutable
-public class RepositoryNodePath {
-
- protected static final Pattern PATTERN = Pattern.compile("([^:/]):(/.*)");
-
- public static RepositoryNodePath parse( String path, String defaultRepositoryWorkspaceName ) {
- Matcher matcher = PATTERN.matcher(path);
- if (matcher.matches()) {
- try {
- return new RepositoryNodePath(matcher.group(1), matcher.group(2));
- } catch (Throwable t) {
- throw new IllegalArgumentException(ServicesI18n.invalidRepositoryNodePath.text(path, t.getMessage()));
- }
- }
- return new RepositoryNodePath(defaultRepositoryWorkspaceName, path);
-
- }
-
- private final String repositoryName;
- private final String nodePath;
- private final int hc;
-
- public RepositoryNodePath( String repositoryName, String nodePath ) {
- this.repositoryName = repositoryName;
- this.nodePath = nodePath;
- this.hc = HashCode.compute(this.repositoryName, this.nodePath);
- }
-
- /**
- * @return nodePath
- */
- public String getNodePath() {
- return this.nodePath;
- }
-
- /**
- * @return repositoryName
- */
- public String getRepositoryWorkspaceName() {
- return this.repositoryName;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public int hashCode() {
- return this.hc;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean equals( Object obj ) {
- if (obj == this) return true;
- if (obj instanceof RepositoryNodePath) {
- RepositoryNodePath that = (RepositoryNodePath)obj;
- if (!this.repositoryName.equals(that.repositoryName)) return false;
- if (!this.nodePath.equals(that.nodePath)) return false;
- return true;
- }
- return false;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public String toString() {
- return this.repositoryName + ":" + this.nodePath;
- }
-}
Deleted: trunk/dna-repository/src/main/java/org/jboss/dna/services/ServiceAdministrator.java
===================================================================
--- trunk/dna-services/src/main/java/org/jboss/dna/services/ServiceAdministrator.java 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/services/ServiceAdministrator.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,144 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source.
- * Copyright 2008, Red Hat Middleware LLC, and individual contributors
- * as indicated by the @author tags. See the copyright.txt file in the
- * distribution for a full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-package org.jboss.dna.services;
-
-import java.util.concurrent.TimeUnit;
-import net.jcip.annotations.ThreadSafe;
-
-/**
- * Contract defining an administrative interface for controlling the running state of a service.
- * @author Randall Hauch
- */
- at ThreadSafe
-public interface ServiceAdministrator {
-
- /**
- * The available states.
- * @author Randall Hauch
- */
- public static enum State {
- STARTED,
- PAUSED,
- SHUTDOWN;
- }
-
- /**
- * Return the current state of this system.
- * @return the current state
- */
- public State getState();
-
- /**
- * Set the state of the system. This method does nothing if the desired state matches the current state.
- * @param state the desired state
- * @return this object for method chaining purposes
- * @see #setState(String)
- * @see #start()
- * @see #pause()
- * @see #shutdown()
- */
- public ServiceAdministrator setState( State state );
-
- /**
- * Set the state of the system. This method does nothing if the desired state matches the current state.
- * @param state the desired state in string form
- * @return this object for method chaining purposes
- * @throws IllegalArgumentException if the specified state string is null or does not match one of the predefined
- * {@link State predefined enumerated values}
- * @see #setState(State)
- * @see #start()
- * @see #pause()
- * @see #shutdown()
- */
- public ServiceAdministrator setState( String state );
-
- /**
- * Start monitoring and sequence the events. This method can be called multiple times, including after the system is
- * {@link #pause() paused}. However, once the system is {@link #shutdown() shutdown}, it cannot be started or paused.
- * @return this object for method chaining purposes
- * @throws IllegalStateException if called when the system has been {@link #shutdown() shutdown}.
- * @see #pause()
- * @see #shutdown()
- * @see #isStarted()
- */
- public ServiceAdministrator start();
-
- /**
- * Temporarily stop monitoring and sequencing events. This method can be called multiple times, including after the system is
- * {@link #start() started}. However, once the system is {@link #shutdown() shutdown}, it cannot be started or paused.
- * @return this object for method chaining purposes
- * @throws IllegalStateException if called when the system has been {@link #shutdown() shutdown}.
- * @see #start()
- * @see #shutdown()
- * @see #isPaused()
- */
- public ServiceAdministrator pause();
-
- /**
- * Permanently stop monitoring and sequencing events. This method can be called multiple times, but only the first call has an
- * effect. Once the system has been shutdown, it may not be {@link #start() restarted} or {@link #pause() paused}.
- * @return this object for method chaining purposes
- * @see #start()
- * @see #pause()
- * @see #isShutdown()
- */
- public ServiceAdministrator shutdown();
-
- /**
- * Blocks until all work has completed execution after a shutdown request, or the timeout occurs, or the current thread is
- * interrupted, whichever happens first.
- * @param timeout the maximum time to wait
- * @param unit the time unit of the timeout argument
- * @return <tt>true</tt> if this service terminated and <tt>false</tt> if the timeout elapsed before termination
- * @throws InterruptedException if interrupted while waiting
- */
- boolean awaitTermination( long timeout, TimeUnit unit ) throws InterruptedException;
-
- /**
- * Return whether this system has been started and is currently running.
- * @return true if started and currently running, or false otherwise
- * @see #start()
- * @see #pause()
- * @see #isPaused()
- * @see #isShutdown()
- */
- public boolean isStarted();
-
- /**
- * Return whether this system is currently paused.
- * @return true if currently paused, or false otherwise
- * @see #pause()
- * @see #start()
- * @see #isStarted()
- * @see #isShutdown()
- */
- public boolean isPaused();
-
- /**
- * Return whether this system is stopped and unable to be restarted.
- * @return true if currently shutdown, or false otherwise
- * @see #shutdown()
- * @see #isPaused()
- * @see #isStarted()
- */
- public boolean isShutdown();
-}
Deleted: trunk/dna-repository/src/main/java/org/jboss/dna/services/ServicesI18n.java
===================================================================
--- trunk/dna-services/src/main/java/org/jboss/dna/services/ServicesI18n.java 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/services/ServicesI18n.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,101 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source.
- * Copyright 2008, Red Hat Middleware LLC, and individual contributors
- * as indicated by the @author tags. See the copyright.txt file in the
- * distribution for a full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-package org.jboss.dna.services;
-
-import org.jboss.dna.common.i18n.I18n;
-
-/**
- * @author Randall Hauch
- */
-public final class ServicesI18n {
-
- static {
- try {
- I18n.initialize(ServicesI18n.class);
- } catch (final Exception err) {
- System.err.println(err);
- }
- }
-
- public static I18n invalidStateString;
- public static I18n serviceShutdowAndMayNotBeStarted;
- public static I18n serviceShutdowAndMayNotBePaused;
- public static I18n unableToFindRepositoryInJndi;
- public static I18n errorProcessingEvents;
- public static I18n errorFindingPropertyNameInPropertyAddedEvent;
- public static I18n errorFindingPropertyNameInPropertyChangedEvent;
- public static I18n errorFindingPropertyNameInPropertyRemovedEvent;
-
- public static I18n unableToObtainJsr94RuleAdministrator;
- public static I18n errorUsingJsr94RuleAdministrator;
- public static I18n unableToObtainJsr94ServiceProvider;
- public static I18n errorAddingOrUpdatingRuleSet;
- public static I18n errorRollingBackRuleSetAfterUpdateFailed;
- public static I18n errorReadingRulesAndProperties;
- public static I18n errorDeregisteringRuleSetBeforeUpdatingIt;
- public static I18n errorRecreatingRuleSet;
- public static I18n errorRemovingRuleSet;
- public static I18n errorRemovingRuleSetUponShutdown;
- public static I18n unableToFindRuleSet;
- public static I18n errorExecutingRuleSetWithGlobalsAndFacts;
- public static I18n unableToBuildRuleSetRegularExpressionPattern;
-
- public static I18n errorObtainingSessionToRepositoryWorkspace;
- public static I18n errorWritingProblemsOnRuleSet;
-
- public static I18n sequencingServiceName;
- public static I18n unableToChangeExecutionContextWhileRunning;
- public static I18n unableToStartSequencingServiceWithoutExecutionContext;
- public static I18n errorWhileSequencingNode;
- public static I18n errorInRepositoryWhileSequencingNode;
- public static I18n errorFindingSequencersToRunAgainstNode;
- public static I18n errorInRepositoryWhileFindingSequencersToRunAgainstNode;
- public static I18n executionContextHasBeenClosed;
- public static I18n sequencerTask;
- public static I18n sequencerSubtask;
- public static I18n unableToFindPropertyForSequencing;
- public static I18n sequencingPropertyOnNode;
- public static I18n writingOutputSequencedFromPropertyOnNodes;
-
- public static I18n errorReadingPropertiesFromContainerNode;
- public static I18n requiredPropertyOnNodeWasExpectedToBeStringValue;
- public static I18n optionalPropertyOnNodeWasExpectedToBeStringValue;
- public static I18n requiredPropertyOnNodeWasExpectedToBeStringArrayValue;
- public static I18n optionalPropertyOnNodeWasExpectedToBeStringArrayValue;
- public static I18n requiredPropertyOnNodeCouldNotBeRead;
- public static I18n optionalPropertyOnNodeCouldNotBeRead;
- public static I18n requiredPropertyIsMissingFromNode;
- public static I18n errorGettingRequiredPropertyFromNode;
- public static I18n errorGettingOptionalPropertyFromNode;
- public static I18n errorClosingBinaryStreamForPropertyFromNode;
- public static I18n requiredNodeDoesNotExistRelativeToNode;
- public static I18n errorGettingNodeRelativeToNode;
- public static I18n unknownPropertyValueType;
-
- public static I18n pathExpressionIsInvalid;
- public static I18n pathExpressionMayNotBeBlank;
- public static I18n pathExpressionHasInvalidSelect;
- public static I18n pathExpressionHasInvalidMatch;
-
- public static I18n invalidRepositoryNodePath;
-
-}
Deleted: trunk/dna-repository/src/main/java/org/jboss/dna/services/SessionFactory.java
===================================================================
--- trunk/dna-services/src/main/java/org/jboss/dna/services/SessionFactory.java 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/main/java/org/jboss/dna/services/SessionFactory.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,35 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source.
- * Copyright 2008, Red Hat Middleware LLC, and individual contributors
- * as indicated by the @author tags. See the copyright.txt file in the
- * distribution for a full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-
-package org.jboss.dna.services;
-
-import javax.jcr.RepositoryException;
-import javax.jcr.Session;
-
-/**
- * @author Randall Hauch
- */
-public interface SessionFactory {
-
- Session createSession( String name ) throws RepositoryException;
-
-}
Added: trunk/dna-repository/src/main/resources/org/jboss/dna/repository/RepositoryI18n.properties
===================================================================
--- trunk/dna-repository/src/main/resources/org/jboss/dna/repository/RepositoryI18n.properties (rev 0)
+++ trunk/dna-repository/src/main/resources/org/jboss/dna/repository/RepositoryI18n.properties 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,61 @@
+invalidStateString = Invalid state parameter "{0}"
+serviceShutdowAndMayNotBeStarted = The {0} has been shutdown and may not be (re)started
+serviceShutdowAndMayNotBePaused = The {0} has been shutdown and my not be paused
+unableToFindRepositoryInJndi = Unable to find a JCR repository in JNDI at '{0}'
+errorProcessingEvents = Error processing events from {0}
+errorFindingPropertyNameInPropertyAddedEvent = Error finding the name of the added property in the event path {0}
+errorFindingPropertyNameInPropertyChangedEvent = Error finding the name of the changed property in the event path {0}
+errorFindingPropertyNameInPropertyRemovedEvent = Error finding the name of the removed property in the event path {0}
+
+unableToObtainJsr94RuleAdministrator = Unable to obtain the rule administrator for JSR-94 service provider {0} ({1}) while adding/updating rule set {2}
+errorUsingJsr94RuleAdministrator = Error using rule administrator for JSR-94 service provider {0} ({1}) while adding/updating rule set {2}
+unableToObtainJsr94ServiceProvider = Error using rule administrator for JSR-94 service provider {0} ({1})
+errorAddingOrUpdatingRuleSet = Error adding/updating rule set '{0}'
+errorRollingBackRuleSetAfterUpdateFailed = Error rolling back rule set '{0}' after new rule set failed
+errorReadingRulesAndProperties = Error reading the rules and properties while adding/updating rule set '{0}'
+errorDeregisteringRuleSetBeforeUpdatingIt = Error deregistering rule set '{0}' before updating it
+errorRecreatingRuleSet = Error (re)creating the rule set '{0}'
+errorRemovingRuleSet = Error removing rule set '{0}'
+errorRemovingRuleSetUponShutdown = Error removing rule set '{0}' upon shutdown
+unableToFindRuleSet = Unable to find rule set with name '{0}'
+errorExecutingRuleSetWithGlobalsAndFacts = Error executing rule set '{0}' and with globals {1} and facts {2}
+unableToBuildRuleSetRegularExpressionPattern = Unable to build the rule set name pattern "{0}" using the supplied absolute path ("{1}"): {2}
+
+errorObtainingSessionToRepositoryWorkspace = Error obtaining JCR session to repository workspace {0}
+errorWritingProblemsOnRuleSet = Error while writing problems on rule set node {0}
+
+sequencingServiceName = Sequencing Service
+unableToChangeExecutionContextWhileRunning = Unable to change the execution context while running
+unableToStartSequencingServiceWithoutExecutionContext = Unable to start the Sequencing Service without an execution context
+errorWhileSequencingNode = Error while sequencer {0} is sequencing node {1}
+errorInRepositoryWhileSequencingNode = Error in repository while sequencer {0} is sequencing node {1}
+errorInRepositoryWhileFindingSequencersToRunAgainstNode = Error in repository while finding sequencers to run against node {0}
+errorFindingSequencersToRunAgainstNode = Error finding sequencers to run against node {0}
+executionContextHasBeenClosed = This execution context has been closed and may not be used to create another session
+sequencerTask = Sequencing {0}
+sequencerSubtask = running {0}
+unableToFindPropertyForSequencing = Unable to find the {0} property while sequencing node {1}
+sequencingPropertyOnNode = Sequencing the {0} property on node {1}
+writingOutputSequencedFromPropertyOnNodes = Writing the output of the sequencing of the {0} property on node {1} to {2} nodes
+
+errorReadingPropertiesFromContainerNode = Error reading properties from property container node {0}
+requiredPropertyOnNodeWasExpectedToBeStringValue = The required {0} property on node {1} was expected to be a string value
+optionalPropertyOnNodeWasExpectedToBeStringValue = The optional {0} property on node {1} was expected to be a string value
+requiredPropertyOnNodeWasExpectedToBeStringArrayValue = The required {0} property on node {1} was expected to be a string array
+optionalPropertyOnNodeWasExpectedToBeStringArrayValue = The optional {0} property on node {1} was expected to be a string array
+requiredPropertyOnNodeCouldNotBeRead = The required {0} property on node {1} could not be read
+optionalPropertyOnNodeCouldNotBeRead = The optional {0} property on node {1} could not be read
+requiredPropertyIsMissingFromNode = The required {0} property is missing from node {1}
+errorGettingRequiredPropertyFromNode = Error while getting the required property {0} from node {1}
+errorGettingOptionalPropertyFromNode = Error while getting the optional property {0} from node {1}
+errorClosingBinaryStreamForPropertyFromNode = Error while closing the binary stream for property {0} on node {1}
+requiredNodeDoesNotExistRelativeToNode = The required node {0} does not exist relative to {1}
+errorGettingNodeRelativeToNode = Error while getting the node {0} (relative to {1})
+unknownPropertyValueType = Property value {0} is of a type ({1}) that is unknown
+
+pathExpressionMayNotBeBlank = The path expression may not be blank
+pathExpressionIsInvalid = The path expression {0} is not valid
+pathExpressionHasInvalidSelect = Invalid select expression '{0}' in the path expression '{1}=>{2}'
+pathExpressionHasInvalidMatch = Invalid match expression '{0}' in the path expression '{1}=>{2}'
+
+invalidRepositoryNodePath = The repository node path '{0}' is not valid: {1}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/observation/NodeChangeTest.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/observation/NodeChangeTest.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/observation/NodeChangeTest.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,65 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.observation;
+
+import java.util.HashSet;
+import java.util.Set;
+import javax.jcr.observation.Event;
+import org.jboss.dna.repository.observation.NodeChange;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author Randall Hauch
+ */
+public class NodeChangeTest {
+
+ private String validRepositoryWorkspaceName;
+ private String validAbsolutePath;
+ private int validEventTypes;
+ private Set<String> validModifiedProperties;
+ private Set<String> validRemovedProperties;
+ private NodeChange nodeChange;
+
+ @Before
+ public void beforeEach() throws Exception {
+ validRepositoryWorkspaceName = "repositoryX";
+ validAbsolutePath = "/a/b/c/d";
+ validEventTypes = Event.NODE_ADDED | Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED | Event.PROPERTY_REMOVED;
+ validModifiedProperties = new HashSet<String>();
+ validRemovedProperties = new HashSet<String>();
+ validModifiedProperties.add("jcr:name");
+ validModifiedProperties.add("jcr:title");
+ validRemovedProperties.add("jcr:mime");
+ nodeChange = new NodeChange(validRepositoryWorkspaceName, validAbsolutePath, validEventTypes, validModifiedProperties, validRemovedProperties);
+ }
+
+ @Test( expected = UnsupportedOperationException.class )
+ public void shouldHaveUnmodifiableSetOfModifiedPropertyNames() {
+ nodeChange.getModifiedProperties().clear();
+ }
+
+ @Test( expected = UnsupportedOperationException.class )
+ public void shouldHaveUnmodifiableSetOfRemovedPropertyNames() {
+ nodeChange.getRemovedProperties().clear();
+ }
+}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleInput.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleInput.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleInput.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,79 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.rules;
+
+public final class RuleInput {
+
+ String mimeType = "";
+ String header = "";
+ String fileName = "";
+
+ /**
+ * @return fileName
+ */
+ public String getFileName() {
+ return fileName;
+ }
+
+ /**
+ * @return header
+ */
+ public String getHeader() {
+ return header;
+ }
+
+ /**
+ * @return mimeType
+ */
+ public String getMimeType() {
+ return mimeType;
+ }
+
+ /**
+ * @param fileName Sets fileName to the specified value.
+ */
+ public void setFileName( String fileName ) {
+ this.fileName = fileName;
+ }
+
+ /**
+ * @param header Sets header to the specified value.
+ */
+ public void setHeader( String header ) {
+ this.header = header;
+ }
+
+ /**
+ * @param mimeType Sets mimeType to the specified value.
+ */
+ public void setMimeType( String mimeType ) {
+ this.mimeType = mimeType;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return this.fileName + " (" + this.mimeType + ") => " + this.header;
+ }
+}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleResult.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleResult.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleResult.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,41 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.rules;
+
+/**
+ * @author John Verhaeg
+ */
+public final class RuleResult {
+
+ String name;
+
+ public RuleResult( String name ) {
+ this.name = name != null ? name : "";
+ }
+
+ /**
+ * @return name
+ */
+ public String getName() {
+ return name;
+ }
+}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleServiceTest.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleServiceTest.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleServiceTest.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,248 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.rules;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.hamcrest.core.IsNot.not;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.hamcrest.core.IsSame.sameInstance;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import java.io.IOException;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.jboss.dna.common.component.ClassLoaderFactory;
+import org.jboss.dna.common.component.StandardClassLoaderFactory;
+import org.jboss.dna.common.util.IoUtil;
+import org.jboss.dna.common.util.Logger;
+import org.jboss.dna.repository.rules.InvalidRuleSetException;
+import org.jboss.dna.repository.rules.RuleService;
+import org.jboss.dna.repository.rules.RuleSet;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author Randall Hauch
+ */
+public class RuleServiceTest {
+
+ protected static final String DROOLS_PROVIDER_CLASSNAME = "org.drools.jsr94.rules.RuleServiceProviderImpl";
+ protected static final String DROOLS_PROVIDER_URI = "http://drools.org/";
+
+ private RuleService ruleService;
+ private ClassLoaderFactory classLoaderFactory;
+
+ protected RuleSet createDroolsRuleSet( String desc ) throws IOException {
+ String name = "SampleRuleSet";
+ String description = desc != null ? desc : "This is a sample rule set that uses Drools";
+ String providerClassname = DROOLS_PROVIDER_CLASSNAME;
+ String providerUri = DROOLS_PROVIDER_URI;
+ String[] providerClasspath = new String[] {};
+ String ruleSetUri = null;
+ URL ruleFile = this.getClass().getResource("/rule_test.dslr");
+ URL dslFile = this.getClass().getResource("/rule_test.dsl");
+ String rules = IoUtil.read(ruleFile.openStream());
+ byte[] dslBytes = IoUtil.readBytes(dslFile.openStream());
+ Map<String, Object> properties = new HashMap<String, Object>();
+ properties.put("javax.rules.admin.RuleExecutionSet.source", "drl"); // as opposed to "xml"
+ properties.put("javax.rules.admin.RuleExecutionSet.dsl", dslBytes);
+ return new RuleSet(name, description, providerClassname, providerClasspath, providerUri, ruleSetUri, rules, properties);
+ }
+
+ protected RuleSet createRuleSetWithInvalidProvider() throws IOException {
+ String name = "SampleRuleSet"; // same name as Drools rule set
+ String description = "This is a sample rule set that uses Drools";
+ String providerClassname = DROOLS_PROVIDER_CLASSNAME;
+ String providerUri = DROOLS_PROVIDER_URI + "this/is/incorrect";
+ String[] providerClasspath = new String[] {};
+ String ruleSetUri = null;
+ URL ruleFile = this.getClass().getResource("/rule_test.dslr");
+ URL dslFile = this.getClass().getResource("/rule_test.dsl");
+ String rules = IoUtil.read(ruleFile.openStream());
+ byte[] dslBytes = IoUtil.readBytes(dslFile.openStream());
+ Map<String, Object> properties = new HashMap<String, Object>();
+ properties.put("javax.rules.admin.RuleExecutionSet.source", "drl"); // as opposed to "xml"
+ properties.put("javax.rules.admin.RuleExecutionSet.dsl", dslBytes);
+ return new RuleSet(name, description, providerClassname, providerClasspath, providerUri, ruleSetUri, rules, properties);
+ }
+
+ @Before
+ public void beforeEach() throws Exception {
+ this.ruleService = new RuleService();
+ this.classLoaderFactory = new StandardClassLoaderFactory();
+ }
+
+ @After
+ public void afterEach() throws Exception {
+ this.ruleService.getAdministrator().shutdown();
+ }
+
+ @Test
+ public void shouldHaveDefaultClasspathFactoryUponConstruction() {
+ assertThat(ruleService.getClassLoaderFactory(), is(notNullValue()));
+ assertThat(ruleService.getClassLoaderFactory(), is(sameInstance(RuleService.DEFAULT_CLASSLOADER_FACTORY)));
+ }
+
+ @Test
+ public void shouldHaveLoggerUponConstruction() {
+ assertThat(ruleService.getLogger(), is(notNullValue()));
+ }
+
+ @Test
+ public void shouldHaveEmptyRuleSetCollectionUponConstruction() {
+ assertThat(ruleService.getRuleSets(), is(notNullValue()));
+ assertThat(ruleService.getRuleSets().isEmpty(), is(true));
+ }
+
+ @Test( expected = UnsupportedOperationException.class )
+ public void shouldReturnUnmodifiableCollectionOfRuleSets() {
+ ruleService.getRuleSets().add(null);
+ }
+
+ @Test
+ public void shouldSetClassLoaderFactoryToDefaultWhenPassedNull() {
+ assertThat(ruleService.getClassLoaderFactory(), is(sameInstance(RuleService.DEFAULT_CLASSLOADER_FACTORY)));
+ ruleService.setClassLoaderFactory(classLoaderFactory);
+ assertThat(ruleService.getClassLoaderFactory(), is(sameInstance(classLoaderFactory)));
+ ruleService.setClassLoaderFactory(null);
+ assertThat(ruleService.getClassLoaderFactory(), is(sameInstance(RuleService.DEFAULT_CLASSLOADER_FACTORY)));
+ }
+
+ @Test
+ public void shouldSetLoggerToDefaultWhenPassedNull() {
+ Logger defaultLogger = ruleService.getLogger();
+ assertThat(ruleService.getLogger(), is(notNullValue()));
+ Logger orgLogger = Logger.getLogger("org");
+ ruleService.setLogger(orgLogger);
+ assertThat(ruleService.getLogger().getName(), is(orgLogger.getName()));
+ assertThat(ruleService.getLogger(), is(sameInstance(orgLogger)));
+ ruleService.setLogger(null);
+ assertThat(ruleService.getLogger().getName(), is(defaultLogger.getName()));
+ assertThat(ruleService.getLogger(), is(not(orgLogger)));
+ }
+
+ @Test( expected = InvalidRuleSetException.class )
+ public void shouldNotAddInvalidRuleSet() throws Exception {
+ ruleService.addRuleSet(createRuleSetWithInvalidProvider());
+
+ }
+
+ @Test
+ public void shouldAddValidRuleSet() throws Exception {
+ int numRuleSetsBefore = ruleService.getRuleSets().size();
+ RuleSet validRuleSet = createDroolsRuleSet(null);
+ assertThat(ruleService.addRuleSet(validRuleSet), is(true));
+ assertThat(ruleService.getRuleSets().size(), is(numRuleSetsBefore + 1));
+ }
+
+ @Test
+ public void shouldNotUpdateValidRuleSetWithInvalidRuleSet() throws Exception {
+ RuleSet validRuleSet = createDroolsRuleSet(null);
+ final String ruleSetName = validRuleSet.getName();
+
+ assertThat(ruleService.addRuleSet(validRuleSet), is(true));
+ assertThat(ruleService.getRuleSets().size(), is(1));
+ assertThat(ruleService.getRuleSets().iterator().next(), is(validRuleSet));
+ // Verify this rule set works ...
+ executeRuleSet(ruleSetName);
+
+ // Try to update the rule set with something that's invalid ...
+ RuleSet invalidRuleSet = createRuleSetWithInvalidProvider();
+ assertThat(invalidRuleSet.getName(), is(ruleSetName));
+ assertThat(invalidRuleSet.getName(), is(validRuleSet.getName()));
+ try {
+ ruleService.addRuleSet(invalidRuleSet);
+ fail("Should not get here");
+ } catch (InvalidRuleSetException e) {
+ // This is expected since it was a bad rule set ...
+ }
+
+ // Verify the original rule set is still there and still works ...
+ assertThat(ruleService.getRuleSets().size(), is(1));
+ assertThat(ruleService.getRuleSets().iterator().next(), is(validRuleSet));
+ executeRuleSet(ruleSetName);
+ }
+
+ @Test
+ public void shouldModifyExistingRuleSetWhenAddedOnlyWhenChanged() throws Exception {
+ int numRuleSetsBefore = ruleService.getRuleSets().size();
+ RuleSet validRuleSet = createDroolsRuleSet(null);
+ assertThat(ruleService.addRuleSet(validRuleSet), is(true));
+ assertThat(ruleService.getRuleSets().size(), is(numRuleSetsBefore + 1));
+
+ // Try to add an unchanged rule set ...
+ RuleSet validRuleSet2 = createDroolsRuleSet(null);
+ assertThat(validRuleSet2.hasChanged(validRuleSet), is(false));
+ assertThat(ruleService.addRuleSet(validRuleSet2), is(false));
+ assertThat(ruleService.getRuleSets().size(), is(numRuleSetsBefore + 1));
+
+ // Try to add a changed rule set ...
+ RuleSet validRuleSet3 = createDroolsRuleSet("This is an alternative description that causes it to be changed");
+ assertThat(validRuleSet3.hasChanged(validRuleSet), is(true));
+ assertThat(ruleService.addRuleSet(validRuleSet3), is(true));
+ assertThat(ruleService.getRuleSets().size(), is(numRuleSetsBefore + 1));
+ }
+
+ @Test
+ public void shouldExecuteRuleSet() throws Exception {
+ RuleSet validRuleSet = createDroolsRuleSet(null);
+ assertThat(ruleService.addRuleSet(validRuleSet), is(true));
+
+ executeRuleSet(validRuleSet.getName());
+ }
+
+ /**
+ * @param validRuleSet
+ */
+ protected void executeRuleSet( String ruleSetName ) {
+ // Create some simple fact objects ...
+ RuleInput info = new RuleInput();
+ info.setFileName("someOtherInput.dsl");
+ info.setHeader("This is the sequencer header");
+ info.setMimeType("text");
+
+ // Run the rules ...
+ Set<String> output = new LinkedHashSet<String>();
+ Map<String, Object> globals = new HashMap<String, Object>();
+ globals.put("output", output);
+
+ List<?> results = ruleService.executeRules(ruleSetName, globals, info);
+ assertThat(results, is(notNullValue()));
+ assertThat(results.isEmpty(), is(false));
+ assertThat(results.size(), is(2));
+ assertTrue(results.get(0) instanceof RuleResult || results.get(1) instanceof RuleResult);
+ // Object result = results.get(0);
+ // assertThat(result, is(instanceOf(RuleResult.class)));
+ assertThat(output.isEmpty(), is(false));
+ Object sequencer = output.iterator().next();
+ assertThat(sequencer, is(instanceOf(String.class)));
+ assertThat(((String)sequencer), is("A"));
+ }
+
+}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleSetTest.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleSetTest.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/rules/RuleSetTest.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,299 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.rules;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.junit.Assert.assertThat;
+import java.io.Reader;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import org.jboss.dna.common.util.IoUtil;
+import org.jboss.dna.repository.rules.RuleSet;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author Randall Hauch
+ */
+public class RuleSetTest {
+
+ private RuleSet ruleSet;
+ private String validName;
+ private String validDescription;
+ private String validClassname;
+ private String[] validClasspath;
+ private String validProviderUri;
+ private String validRuleSetUri;
+ private String validRules;
+ private Map<String, Object> validProperties;
+
+ @Before
+ public void beforeEach() throws Exception {
+ this.validName = "This is a valid name";
+ this.validDescription = "This is a valid description";
+ this.validClassname = "com.acme.SuperDuper";
+ this.validClasspath = new String[] {"classpath1", "classpath2"};
+ this.validProviderUri = "http://www.acme.com/super/duper/rules_engine";
+ this.validRuleSetUri = "com.something.whatever doesn't really need to be a URI";
+ this.validRules = "when something is true then cheer";
+ this.validProperties = new HashMap<String, Object>();
+ this.validProperties.put("key1", "value1");
+ this.validProperties.put("key2", null);
+ this.validProperties.put("key3", "value3".getBytes());
+ this.ruleSet = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowNullName() {
+ new RuleSet(null, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowEmptyName() {
+ new RuleSet("", validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowBlankName() {
+ new RuleSet(" \t ", validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test
+ public void shouldTrimName() {
+ validName = " this is a valid name with leading and trailing whitespace ";
+ ruleSet = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(ruleSet.getName(), is(validName.trim()));
+ }
+
+ @Test
+ public void shouldAllowNullOrEmptyOrBlankDescriptionAndShouldReplaceWithEmptyString() {
+ ruleSet = new RuleSet(validName, null, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(ruleSet.getDescription(), is(""));
+ ruleSet = new RuleSet(validName, "", validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(ruleSet.getDescription(), is(""));
+ ruleSet = new RuleSet(validName, " \t ", validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(ruleSet.getDescription(), is(""));
+ }
+
+ @Test
+ public void shouldTrimDescription() {
+ ruleSet = new RuleSet(validName, " valid ", validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(ruleSet.getDescription(), is("valid"));
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowNullClassname() {
+ new RuleSet(validName, validDescription, null, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowEmptyClassname() {
+ new RuleSet(validName, validDescription, "", validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowBlankClassname() {
+ new RuleSet(validName, validDescription, " ", validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowClassnameThatDoesNotFollowJavaNamingRules() {
+ new RuleSet(validName, validDescription, "not a valid classname", validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test
+ public void shouldAllowNullOrEmptyClasspath() {
+ new RuleSet(validName, validDescription, validClassname, null, validProviderUri, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test
+ public void shouldRemoveNullOrBlankClasspathItems() {
+ new RuleSet(validName, validDescription, validClassname, new String[] {}, validProviderUri, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test
+ public void shouldRemoveDuplicateClasspathItemsInCaseSensitiveManner() {
+ validClasspath = new String[] {"path1", "path2", "path1", "path3", "path2"};
+ ruleSet = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(ruleSet.getComponentClasspathArray(), is(new String[] {"path1", "path2", "path3"}));
+
+ validClasspath = new String[] {"path1", "path2", "path1", "path3", "Path2"};
+ ruleSet = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(ruleSet.getComponentClasspathArray(), is(new String[] {"path1", "path2", "path3", "Path2"}));
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowNullProviderUri() {
+ new RuleSet(validName, validDescription, validClassname, validClasspath, null, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowEmptyProviderUri() {
+ new RuleSet(validName, validDescription, validClassname, validClasspath, "", validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowBlankProviderUri() {
+ new RuleSet(validName, validDescription, validClassname, validClasspath, " \t ", validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test
+ public void shouldUseNameInPlaceOfNullRuleSetUri() {
+ ruleSet = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, null, validRules, validProperties);
+ assertThat(ruleSet.getRuleSetUri(), is(ruleSet.getName()));
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowEmptyRuleSetUri() {
+ new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, "", validRules, validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowBlankRuleSetUri() {
+ new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, " \t ", validRules, validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowNullRules() {
+ new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, null, validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowEmptyRules() {
+ new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, "", validProperties);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowBlankRules() {
+ new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, " \t ", validProperties);
+ }
+
+ @Test
+ public void shouldAllowNullOrEmptyProperties() {
+ validProperties = null;
+ ruleSet = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(ruleSet.getProperties(), is(notNullValue()));
+ }
+
+ @Test
+ public void shouldWrapByteArrayPropertyValuesWithInputStreamInExecutionSetProperties() throws Exception {
+ Map<Object, Object> executionSetProps = ruleSet.getExecutionSetProperties();
+ assertThat(executionSetProps.size(), is(ruleSet.getProperties().size()));
+ assertThat(executionSetProps.keySet(), is((Set<Object>)new HashSet<Object>(ruleSet.getProperties().keySet())));
+ Iterator<Map.Entry<Object, Object>> executionSetPropIter = executionSetProps.entrySet().iterator();
+ Iterator<Map.Entry<String, Object>> propIter = ruleSet.getProperties().entrySet().iterator();
+ while (executionSetPropIter.hasNext() && propIter.hasNext()) {
+ Map.Entry<Object, Object> execSetEntry = executionSetPropIter.next();
+ Object execSetKey = execSetEntry.getKey();
+ Object execSetValue = execSetEntry.getValue();
+ Map.Entry<String, Object> propertyEntry = propIter.next();
+ String propertyKey = propertyEntry.getKey();
+ Object propertyValue = propertyEntry.getValue();
+ // Check the entries ...
+ assertThat(execSetKey, is((Object)propertyKey));
+ if (propertyValue instanceof byte[]) {
+ assertThat(execSetValue, is(instanceOf(Reader.class)));
+ String streamValueAsString = IoUtil.read((Reader)execSetValue);
+ String propertyValueAsString = new String((byte[])propertyValue);
+ assertThat(streamValueAsString, is(propertyValueAsString));
+ } else {
+ assertThat(execSetValue, is(propertyValue));
+ }
+ }
+ assertThat(executionSetPropIter.hasNext(), is(false));
+ assertThat(propIter.hasNext(), is(false));
+
+ new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ }
+
+ @Test
+ public void shouldConsiderAnyAttributeDifferencesAsChange() {
+ RuleSet copy = ruleSet.clone();
+ assertThat(copy.hasChanged(ruleSet), is(false));
+ assertThat(copy.hasChanged(copy), is(false));
+
+ copy = new RuleSet(validName + "x", validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(copy.hasChanged(ruleSet), is(true));
+ assertThat(copy.hasChanged(copy), is(false));
+
+ copy = new RuleSet(validName, validDescription + "x", validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(copy.hasChanged(ruleSet), is(true));
+ assertThat(copy.hasChanged(copy), is(false));
+
+ copy = new RuleSet(validName, validDescription, validClassname + "x", validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(copy.hasChanged(ruleSet), is(true));
+ assertThat(copy.hasChanged(copy), is(false));
+
+ copy = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri + "x", validRuleSetUri, validRules, validProperties);
+ assertThat(copy.hasChanged(ruleSet), is(true));
+ assertThat(copy.hasChanged(copy), is(false));
+
+ validClasspath = new String[] {"classpath1", "classpath2x"};
+ copy = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri + "x", validRules, validProperties);
+ assertThat(copy.hasChanged(ruleSet), is(true));
+ assertThat(copy.hasChanged(copy), is(false));
+
+ copy = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules + "x", validProperties);
+ assertThat(copy.hasChanged(ruleSet), is(true));
+ assertThat(copy.hasChanged(copy), is(false));
+
+ validProperties.remove("key1");
+ copy = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(copy.hasChanged(ruleSet), is(true));
+ assertThat(copy.hasChanged(copy), is(false));
+ }
+
+ @Test
+ public void shouldConsiderOnlyNameWhenDeterminingIfSame() {
+ RuleSet copy = ruleSet.clone();
+ assertThat(copy.equals(ruleSet), is(true));
+
+ copy = new RuleSet(validName + "x", validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(copy.equals(ruleSet), is(false));
+
+ copy = new RuleSet(validName, validDescription + "x", validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(copy.equals(ruleSet), is(true));
+
+ copy = new RuleSet(validName, validDescription, validClassname + "x", validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(copy.equals(ruleSet), is(true));
+
+ copy = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri + "x", validRuleSetUri, validRules, validProperties);
+ assertThat(copy.equals(ruleSet), is(true));
+
+ validClasspath = new String[] {"classpath1", "classpath2x"};
+ copy = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri + "x", validRules, validProperties);
+ assertThat(copy.equals(ruleSet), is(true));
+
+ copy = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules + "x", validProperties);
+ assertThat(copy.equals(ruleSet), is(true));
+
+ validProperties.remove("key1");
+ copy = new RuleSet(validName, validDescription, validClassname, validClasspath, validProviderUri, validRuleSetUri, validRules, validProperties);
+ assertThat(copy.equals(ruleSet), is(true));
+ }
+
+}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/MockSequencerA.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/MockSequencerA.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/MockSequencerA.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,102 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.jboss.dna.repository.sequencers;
+
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import javax.jcr.Node;
+import net.jcip.annotations.ThreadSafe;
+import org.jboss.dna.common.CoreI18n;
+import org.jboss.dna.common.monitor.ProgressMonitor;
+import org.jboss.dna.repository.observation.NodeChange;
+import org.jboss.dna.repository.sequencers.Sequencer;
+import org.jboss.dna.repository.sequencers.SequencerConfig;
+import org.jboss.dna.repository.util.ExecutionContext;
+import org.jboss.dna.repository.util.RepositoryNodePath;
+
+/**
+ * A sequencer that can be used for basic unit testing.
+ * @author Randall Hauch
+ */
+ at ThreadSafe
+public class MockSequencerA implements Sequencer {
+
+ private SequencerConfig config;
+ private AtomicInteger counter = new AtomicInteger();
+ private CountDownLatch latch = new CountDownLatch(0);
+
+ public void setExpectedCount( int numExpected ) {
+ this.latch = new CountDownLatch(numExpected);
+ }
+
+ public boolean awaitExecution( long timeout, TimeUnit unit ) throws InterruptedException {
+ return this.latch.await(timeout, unit);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void setConfiguration( SequencerConfig sequencerConfiguration ) {
+ this.config = sequencerConfiguration;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void execute( Node input, String sequencedPropertyName, NodeChange changes, Set<RepositoryNodePath> outputPaths, ExecutionContext context, ProgressMonitor progress ) {
+ try {
+ progress.beginTask(1, CoreI18n.passthrough, "Incrementing counter");
+ // increment the counter and record the progress ...
+ this.counter.incrementAndGet();
+ this.latch.countDown();
+ progress.worked(1);
+ } finally {
+ progress.done();
+ }
+ }
+
+ public int getCounter() {
+ return this.counter.get();
+ }
+
+ public boolean isConfigured() {
+ return this.config != null;
+ }
+
+ /**
+ * @return config
+ */
+ public SequencerConfig getConfiguration() {
+ return this.config;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return (this.config != null ? this.config.getName() : "SampleSequencer") + " [" + this.getCounter() + "]";
+ }
+}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/MockSequencerB.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/MockSequencerB.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/MockSequencerB.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,102 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.jboss.dna.repository.sequencers;
+
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import javax.jcr.Node;
+import net.jcip.annotations.ThreadSafe;
+import org.jboss.dna.common.CoreI18n;
+import org.jboss.dna.common.monitor.ProgressMonitor;
+import org.jboss.dna.repository.observation.NodeChange;
+import org.jboss.dna.repository.sequencers.Sequencer;
+import org.jboss.dna.repository.sequencers.SequencerConfig;
+import org.jboss.dna.repository.util.ExecutionContext;
+import org.jboss.dna.repository.util.RepositoryNodePath;
+
+/**
+ * A sequencer that can be used for basic unit testing.
+ * @author Randall Hauch
+ */
+ at ThreadSafe
+public class MockSequencerB implements Sequencer {
+
+ private SequencerConfig config;
+ private AtomicInteger counter = new AtomicInteger();
+ private CountDownLatch latch = new CountDownLatch(0);
+
+ public void setExpectedCount( int numExpected ) {
+ this.latch = new CountDownLatch(numExpected);
+ }
+
+ public boolean awaitExecution( long timeout, TimeUnit unit ) throws InterruptedException {
+ return this.latch.await(timeout, unit);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void setConfiguration( SequencerConfig sequencerConfiguration ) {
+ this.config = sequencerConfiguration;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void execute( Node input, String sequencedPropertyName, NodeChange changes, Set<RepositoryNodePath> outputPaths, ExecutionContext context, ProgressMonitor progress ) {
+ try {
+ progress.beginTask(1, CoreI18n.passthrough, "Incrementing counter");
+ // increment the counter and record the progress ...
+ this.counter.incrementAndGet();
+ this.latch.countDown();
+ progress.worked(1);
+ } finally {
+ progress.done();
+ }
+ }
+
+ public int getCounter() {
+ return this.counter.get();
+ }
+
+ public boolean isConfigured() {
+ return this.config != null;
+ }
+
+ /**
+ * @return config
+ */
+ public SequencerConfig getConfiguration() {
+ return this.config;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return (this.config != null ? this.config.getName() : "SampleSequencer") + " [" + this.getCounter() + "]";
+ }
+}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencerConfigTest.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencerConfigTest.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencerConfigTest.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,131 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.jboss.dna.repository.sequencers;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+import org.jboss.dna.repository.sequencers.SequencerConfig;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author Randall Hauch
+ */
+public class SequencerConfigTest {
+
+ private SequencerConfig configA;
+ private SequencerConfig configB;
+ private SequencerConfig configA2;
+ private String validName;
+ private String validDescription;
+ private String validClassname;
+ private String[] validPathExpressions;
+ private String[] validMavenIds;
+
+ @Before
+ public void beforeEach() throws Exception {
+ this.validName = "valid configuration name";
+ this.validDescription = "a sequencer";
+ this.validClassname = MockSequencerA.class.getName();
+ this.validPathExpressions = new String[] {"/a/b/c/d[e/@attribute] => ."};
+ this.validMavenIds = new String[] {"com.acme:configA:1.0,com.acme:configB:1.0"};
+ this.configA = new SequencerConfig("configA", validDescription, MockSequencerA.class.getName(), validMavenIds, validPathExpressions);
+ this.configB = new SequencerConfig("configB", validDescription, MockSequencerB.class.getName(), validMavenIds, validPathExpressions);
+ this.configA2 = new SequencerConfig("conFigA", validDescription, MockSequencerA.class.getName(), validMavenIds, validPathExpressions);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowNullNameInConstructor() {
+ new SequencerConfig(null, validDescription, validClassname, validMavenIds, validPathExpressions);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowEmptyNameInConstructor() {
+ new SequencerConfig("", validDescription, validClassname, validMavenIds, validPathExpressions);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowBlankNameInConstructor() {
+ new SequencerConfig(" \t", validDescription, validClassname, validMavenIds, validPathExpressions);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowNullClassNameInConstructor() {
+ new SequencerConfig(validName, validDescription, null, validMavenIds, validPathExpressions);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowEmptyClassNameInConstructor() {
+ new SequencerConfig(validName, validDescription, "", validMavenIds, validPathExpressions);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowBlankClassNameInConstructor() {
+ new SequencerConfig(validName, validDescription, " \t", validMavenIds, validPathExpressions);
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowInvalidClassNameInConstructor() {
+ new SequencerConfig(validName, validDescription, "12.this is not a valid classname", validMavenIds, validPathExpressions);
+ }
+
+ @Test
+ public void shouldConsiderSameIfNamesAreEqualIgnoringCase() {
+ assertThat(configA.equals(configA2), is(true));
+ }
+
+ @Test
+ public void shouldConsiderNotSameIfNamesAreNotEqualIgnoringCase() {
+ assertThat(configA.equals(configB), is(false));
+ }
+
+ @Test
+ public void shouldNotAddNullOrBlankPathExpressions() {
+ assertThat(SequencerConfig.buildPathExpressionSet(null, "", " ", validPathExpressions[0]).size(), is(1));
+ }
+
+ @Test
+ public void shouldNotAddSamePathExpressionMoreThanOnce() {
+ assertThat(SequencerConfig.buildPathExpressionSet(validPathExpressions[0], validPathExpressions[0], validPathExpressions[0]).size(), is(1));
+ }
+
+ @Test
+ public void shouldHaveNonNullPathExpressionCollectionWhenThereAreNoPathExpressions() {
+ configA = new SequencerConfig("configA", validDescription, validClassname, validMavenIds);
+ assertThat(configA.getPathExpressions().size(), is(0));
+ }
+
+ @Test
+ public void shouldSetClasspathWithValidMavenIds() {
+ assertThat(configA.getComponentClasspath().size(), is(validMavenIds.length));
+ assertThat(configA.getComponentClasspathArray(), is(validMavenIds));
+ }
+
+ @Test
+ public void shouldGetNonNullSequencerClasspathWhenEmpty() {
+ configA = new SequencerConfig("configA", validDescription, validClassname, null, validPathExpressions);
+ assertThat(configA.getComponentClasspath().size(), is(0));
+ assertThat(configA.getComponentClasspathArray().length, is(0));
+ }
+
+}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencerPathExpressionTest.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencerPathExpressionTest.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencerPathExpressionTest.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,356 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.sequencers;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.junit.Assert.assertThat;
+import org.jboss.dna.repository.sequencers.InvalidSequencerPathExpression;
+import org.jboss.dna.repository.sequencers.SequencerPathExpression;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author Randall Hauch
+ */
+public class SequencerPathExpressionTest {
+
+ private SequencerPathExpression expr;
+
+ @Before
+ public void beforeEach() throws Exception {
+ expr = new SequencerPathExpression(".*", "/output");
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotCompileNullExpression() {
+ SequencerPathExpression.compile(null);
+ }
+
+ @Test( expected = InvalidSequencerPathExpression.class )
+ public void shouldNotCompileZeroLengthExpression() {
+ SequencerPathExpression.compile("");
+ }
+
+ @Test( expected = InvalidSequencerPathExpression.class )
+ public void shouldNotCompileBlankExpression() {
+ SequencerPathExpression.compile(" ");
+ }
+
+ @Test
+ public void shouldCompileExpressionWithOnlySelectionExpression() {
+ expr = SequencerPathExpression.compile("/a/b/c");
+ assertThat(expr, is(notNullValue()));
+ assertThat(expr.getSelectExpression(), is("/a/b/c"));
+ assertThat(expr.getOutputExpression(), is(SequencerPathExpression.DEFAULT_OUTPUT_EXPRESSION));
+ }
+
+ @Test( expected = InvalidSequencerPathExpression.class )
+ public void shouldNotCompileExpressionWithSelectionExpressionAndDelimiterAndNoOutputExpression() {
+ SequencerPathExpression.compile("/a/b/c=>");
+ }
+
+ @Test
+ public void shouldCompileExpressionWithSelectionExpressionAndDelimiterAndOutputExpression() {
+ expr = SequencerPathExpression.compile("/a/b/c=>.");
+ assertThat(expr, is(notNullValue()));
+ assertThat(expr.getSelectExpression(), is("/a/b/c"));
+ assertThat(expr.getOutputExpression(), is("."));
+
+ expr = SequencerPathExpression.compile("/a/b/c=>/x/y");
+ assertThat(expr, is(notNullValue()));
+ assertThat(expr.getSelectExpression(), is("/a/b/c"));
+ assertThat(expr.getOutputExpression(), is("/x/y"));
+ }
+
+ @Test
+ public void shouldCompileExpressionWithExtraWhitespace() {
+ expr = SequencerPathExpression.compile(" /a/b/c => . ");
+ assertThat(expr, is(notNullValue()));
+ assertThat(expr.getSelectExpression(), is("/a/b/c"));
+ assertThat(expr.getOutputExpression(), is("."));
+
+ expr = SequencerPathExpression.compile(" /a/b/c => /x/y ");
+ assertThat(expr, is(notNullValue()));
+ assertThat(expr.getSelectExpression(), is("/a/b/c"));
+ assertThat(expr.getOutputExpression(), is("/x/y"));
+ }
+
+ @Test
+ public void shouldCompileExpressionWithIndexes() {
+ assertThat(SequencerPathExpression.compile("/a/b[0]/c[1]/d/e"), is(notNullValue()));
+ assertThat(SequencerPathExpression.compile("/a/b[0]/c[1]/d/e[2]"), is(notNullValue()));
+ }
+
+ @Test
+ public void shouldNotRemoveUsedPredicates() {
+ assertThat(expr.removeUnusedPredicates("/a/b/c"), is("/a/b/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[0]/c"), is("/a/b[0]/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[1]/c"), is("/a/b[1]/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[10]/c"), is("/a/b[10]/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[100]/c"), is("/a/b[100]/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[1000]/c"), is("/a/b[1000]/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[]/c"), is("/a/b[]/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[*]/c"), is("/a/b[*]/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[1,2]/c"), is("/a/b[1,2]/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[1,2,3,4,5]/c"), is("/a/b[1,2,3,4,5]/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b/c[@title]"), is("/a/b/c[@title]"));
+ assertThat(expr.removeUnusedPredicates("/a/b/c[d/e/@title]"), is("/a/b/c[d/e/@title]"));
+ assertThat(expr.removeUnusedPredicates("/a/(b/c)[(d|e)/(f|g)/@something]"), is("/a/(b/c)[(d|e)/(f|g)/@something]"));
+ // These are legal, but aren't really useful ...
+ assertThat(expr.removeUnusedPredicates("/a/b[1][2][3]/c"), is("/a/b[1][2][3]/c"));
+ }
+
+ @Test
+ public void shouldRemoveUnusedPredicates() {
+ assertThat(expr.removeUnusedPredicates("/a/b[-1]/c"), is("/a/b/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[@name='wacky']/c"), is("/a/b/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[3][@name='wacky']/c"), is("/a/b[3]/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[3][@name]/c"), is("/a/b[3]/c"));
+ assertThat(expr.removeUnusedPredicates("/a/b[length(@name)=3]/c"), is("/a/b/c"));
+ }
+
+ @Test
+ public void shouldRemoveAllPredicates() {
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b/c"), is("/a/b/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[0]/c"), is("/a/b[0]/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[1]/c"), is("/a/b[1]/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[10]/c"), is("/a/b[10]/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[100]/c"), is("/a/b[100]/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[1000]/c"), is("/a/b[1000]/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[]/c"), is("/a/b[]/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[*]/c"), is("/a/b[*]/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b/c[@title]"), is("/a/b/c"));
+ // These are legal, but aren't really useful ...
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[1][2][3]/c"), is("/a/b[1][2][3]/c"));
+
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[-1]/c"), is("/a/b/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[@name='wacky']/c"), is("/a/b/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[3][@name='wacky']/c"), is("/a/b[3]/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[3][@name]/c"), is("/a/b[3]/c"));
+ assertThat(expr.removeAllPredicatesExceptIndexes("/a/b[length(@name)=3]/c"), is("/a/b/c"));
+ }
+
+ @Test
+ public void shouldReplaceAllXPathPatterns() {
+ assertThat(expr.replaceXPathPatterns("/a/b[3]/c"), is("/a/b\\[3\\]/c"));
+ assertThat(expr.replaceXPathPatterns("/a/b[*]/c"), is("/a/b(?:\\[\\d+\\])?/c"));
+ assertThat(expr.replaceXPathPatterns("/a/b[]/c"), is("/a/b(?:\\[\\d+\\])?/c"));
+ assertThat(expr.replaceXPathPatterns("/a/b[0]/c"), is("/a/b(?:\\[0\\])?/c"));
+ assertThat(expr.replaceXPathPatterns("/a/b[0,1,2,4]/c"), is("/a/b(?:\\[(?:1|2|4)\\])?/c"));
+ assertThat(expr.replaceXPathPatterns("/a/b[1,2,4,0]/c"), is("/a/b(?:\\[(?:1|2|4)\\])?/c"));
+ assertThat(expr.replaceXPathPatterns("/a/b[1,2,0,4]/c"), is("/a/b(?:\\[(?:1|2|4)\\])?/c"));
+ assertThat(expr.replaceXPathPatterns("/a/b[0,1,2,0,4,0]/c"), is("/a/b(?:\\[(?:1|2|4)\\])?/c"));
+ assertThat(expr.replaceXPathPatterns("/a/b[1,2,4]/c"), is("/a/b\\[(?:1|2|4)\\]/c"));
+ assertThat(expr.replaceXPathPatterns("/a/b[@param]"), is("/a/b/@param"));
+ assertThat(expr.replaceXPathPatterns("/a/b[3][@param]"), is("/a/b\\[3\\]/@param"));
+ assertThat(expr.replaceXPathPatterns("/a/b[c/d/@param]"), is("/a/b/c/d/@param"));
+
+ assertThat(expr.replaceXPathPatterns("/a/(b|c|d)/e"), is("/a/(b|c|d)/e"));
+ assertThat(expr.replaceXPathPatterns("/a/(b||c|d)/e"), is("/a/(b|c|d)/e"));
+ assertThat(expr.replaceXPathPatterns("/a/(b|||c|d)/e"), is("/a/(b|c|d)/e"));
+ assertThat(expr.replaceXPathPatterns("/a/(|b|c|d)/e"), is("/a(/(b|c|d))?/e"));
+ assertThat(expr.replaceXPathPatterns("/a/(b|c|d|)/e"), is("/a(/(b|c|d))?/e"));
+ assertThat(expr.replaceXPathPatterns("/a/(b|c|d)[]/e"), is("/a/(b|c|d)(?:\\[\\d+\\])?/e"));
+ assertThat(expr.replaceXPathPatterns("/a/(b|c[2]|d[])/e"), is("/a/(b|c\\[2\\]|d(?:\\[\\d+\\])?)/e"));
+ assertThat(expr.replaceXPathPatterns("/a/(b|c/d|e)/f"), is("/a/(b|c/d|e)/f"));
+ assertThat(expr.replaceXPathPatterns("/a/(b/c)[(d|e)/(f|g)/@something]"), is("/a/(b/c)/(d|e)/(f|g)/@something"));
+
+ assertThat(expr.replaceXPathPatterns("/a/*/f"), is("/a/[^/]*/f"));
+ assertThat(expr.replaceXPathPatterns("/a//f"), is("/a(/[^/]*)*/f"));
+ assertThat(expr.replaceXPathPatterns("/a///f"), is("/a(/[^/]*)*/f"));
+ assertThat(expr.replaceXPathPatterns("/a/////f"), is("/a(/[^/]*)*/f"));
+ }
+
+ protected void assertNotMatches( SequencerPathExpression.Matcher matcher ) {
+ assertThat(matcher, is(notNullValue()));
+ assertThat(matcher.getSelectedPath(), is(nullValue()));
+ assertThat(matcher.getOutputPath(), is(nullValue()));
+ assertThat(matcher.matches(), is(false));
+ }
+
+ protected void assertMatches( SequencerPathExpression.Matcher matcher, String selectedPath, String outputPath ) {
+ assertThat(matcher, is(notNullValue()));
+ assertThat(matcher.getSelectedPath(), is(selectedPath));
+ assertThat(matcher.getOutputPath(), is(outputPath));
+ if (selectedPath == null) {
+ assertThat(matcher.matches(), is(false));
+ } else {
+ assertThat(matcher.matches(), is(true));
+ }
+ }
+
+ @Test
+ public void shouldMatchExpressionsWithoutRegardToCase() {
+ expr = SequencerPathExpression.compile("/a/b/c/d/e[@something] => .");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c/d/e", "/a/b/c/d/e");
+ assertMatches(expr.matcher("/a/b/c/d/E/@something"), "/a/b/c/d/E", "/a/b/c/d/E");
+ }
+
+ @Test
+ public void shouldMatchExpressionsWithExactFullPath() {
+ expr = SequencerPathExpression.compile("/a/b/c/d/e[@something] => .");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c/d/e", "/a/b/c/d/e");
+ assertNotMatches(expr.matcher("/a/b/c/d/E/@something2"));
+ assertNotMatches(expr.matcher("/a/b/c/d/ex/@something"));
+ assertNotMatches(expr.matcher("/a/b[1]/c/d/e/@something"));
+ }
+
+ @Test
+ public void shouldMatchExpressionsWithExactFullPathAndExtraPathInsideMatch() {
+ expr = SequencerPathExpression.compile("/a/b/c[d/e/@something] => .");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c", "/a/b/c");
+ assertNotMatches(expr.matcher("/a/b/c/d/E/@something2"));
+ assertNotMatches(expr.matcher("/a/b/c/d/ex/@something"));
+ assertNotMatches(expr.matcher("/a/b[1]/c/d/e/@something"));
+ }
+
+ @Test
+ public void shouldMatchExpressionsWithWildcardSelection() {
+ expr = SequencerPathExpression.compile("/a/*/c[d/e/@something] => .");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c", "/a/b/c");
+ assertMatches(expr.matcher("/a/b[2]/c/d/e/@something"), "/a/b[2]/c", "/a/b[2]/c");
+ assertMatches(expr.matcher("/a/rt/c/d/e/@something"), "/a/rt/c", "/a/rt/c");
+ assertNotMatches(expr.matcher("/ac/d/e/@something"));
+ }
+
+ @Test
+ public void shouldMatchExpressionsWithSegmentWildcardSelection() {
+ expr = SequencerPathExpression.compile("/a//c[d/e/@something] => .");
+ assertMatches(expr.matcher("/a/c/d/e/@something"), "/a/c", "/a/c");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c", "/a/b/c");
+ assertMatches(expr.matcher("/a/b[2]/c/d/e/@something"), "/a/b[2]/c", "/a/b[2]/c");
+ assertMatches(expr.matcher("/a/rt/c/d/e/@something"), "/a/rt/c", "/a/rt/c");
+ assertMatches(expr.matcher("/a/r/s/t/c/d/e/@something"), "/a/r/s/t/c", "/a/r/s/t/c");
+ assertMatches(expr.matcher("/a/r[1]/s[2]/t[33]/c/d/e/@something"), "/a/r[1]/s[2]/t[33]/c", "/a/r[1]/s[2]/t[33]/c");
+ assertNotMatches(expr.matcher("/a[3]/c/d/e/@something"));
+ }
+
+ @Test
+ public void shouldMatchExpressionsWithIndexesInSelectionPaths() {
+ expr = SequencerPathExpression.compile("/a/b[2,3,4,5]/c/d/e[@something] => /x/y");
+ assertMatches(expr.matcher("/a/b[2]/c/d/e/@something"), "/a/b[2]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[3]/c/d/e/@something"), "/a/b[3]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[4]/c/d/e/@something"), "/a/b[4]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[5]/c/d/e/@something"), "/a/b[5]/c/d/e", "/x/y");
+ assertNotMatches(expr.matcher("/a/b[1]/c/d/e/@something"));
+ assertNotMatches(expr.matcher("/a/b/c/d/e/@something"));
+ assertNotMatches(expr.matcher("/a[1]/b/c/d/e/@something"));
+
+ expr = SequencerPathExpression.compile("/a/b[0,2,3,4,5]/c/d/e[@something] => /x/y");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[2]/c/d/e/@something"), "/a/b[2]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[3]/c/d/e/@something"), "/a/b[3]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[4]/c/d/e/@something"), "/a/b[4]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[5]/c/d/e/@something"), "/a/b[5]/c/d/e", "/x/y");
+ assertNotMatches(expr.matcher("/a/b[1]/c/d/e/@something"));
+ assertNotMatches(expr.matcher("/a[1]/b/c/d/e/@something"));
+ }
+
+ @Test
+ public void shouldMatchExpressionsWithAnyIndexesInSelectionPaths() {
+ expr = SequencerPathExpression.compile("/a/b[*]/c[]/d/e[@something] => /x/y");
+ assertMatches(expr.matcher("/a/b[2]/c/d/e/@something"), "/a/b[2]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[3]/c/d/e/@something"), "/a/b[3]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[4]/c/d/e/@something"), "/a/b[4]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[5]/c/d/e/@something"), "/a/b[5]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[1]/c/d/e/@something"), "/a/b[1]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[6]/c/d/e/@something"), "/a/b[6]/c/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b[6]/c[1]/d/e/@something"), "/a/b[6]/c[1]/d/e", "/x/y");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c/d/e", "/x/y");
+ }
+
+ @Test
+ public void shouldMatchExpressionsWithFullOutputPath() {
+ expr = SequencerPathExpression.compile("/a/b/c[d/e/@something] => /x/y");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c", "/x/y");
+ }
+
+ @Test
+ public void shouldMatchExpressionsWithRepositoryInSelectionPath() {
+ expr = SequencerPathExpression.compile("reposA:/a/b/c[d/e/@something] => /x/y");
+ assertMatches(expr.matcher("reposA:/a/b/c/d/e/@something"), "reposA:/a/b/c", "/x/y");
+ }
+
+ @Test
+ public void shouldMatchExpressionsWithRepositoryInFullOutputPath() {
+ expr = SequencerPathExpression.compile("/a/b/c[d/e/@something] => reposA:/x/y");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c", "reposA:/x/y");
+ }
+
+ @Test
+ public void shouldMatchExpressionsWithNamedGroupsInOutputPath() {
+ expr = SequencerPathExpression.compile("/a(//c)[d/e/@something] => $1/y/z");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c", "/b/c/y/z");
+
+ expr = SequencerPathExpression.compile("/a(/(b|c|d|)/e)[f/g/@something] => $1/y/z");
+ assertMatches(expr.matcher("/a/b/e/f/g/@something"), "/a/b/e", "/b/e/y/z");
+ assertMatches(expr.matcher("/a/c/e/f/g/@something"), "/a/c/e", "/c/e/y/z");
+ assertMatches(expr.matcher("/a/d/e/f/g/@something"), "/a/d/e", "/d/e/y/z");
+ assertMatches(expr.matcher("/a/e/f/g/@something"), "/a/e", "/e/y/z");
+ assertNotMatches(expr.matcher("/a/t/e/f/g/@something"));
+
+ expr = SequencerPathExpression.compile("/a/(b/c)[(d|e)/(f|g)/@something] => /u/$1/y/z/$2/$3");
+ assertMatches(expr.matcher("/a/b/c/d/f/@something"), "/a/b/c", "/u/b/c/y/z/d/f");
+ assertMatches(expr.matcher("/a/b/c/e/f/@something"), "/a/b/c", "/u/b/c/y/z/e/f");
+ assertMatches(expr.matcher("/a/b/c/d/g/@something"), "/a/b/c", "/u/b/c/y/z/d/g");
+ assertMatches(expr.matcher("/a/b/c/e/g/@something"), "/a/b/c", "/u/b/c/y/z/e/g");
+
+ expr = SequencerPathExpression.compile("/a/(b/c)/(d|e)/(f|g)/@something => /u/$1/y/z/$2/$3");
+ assertMatches(expr.matcher("/a/b/c/d/f/@something"), "/a/b/c/d/f", "/u/b/c/y/z/d/f");
+ assertMatches(expr.matcher("/a/b/c/e/f/@something"), "/a/b/c/e/f", "/u/b/c/y/z/e/f");
+ assertMatches(expr.matcher("/a/b/c/d/g/@something"), "/a/b/c/d/g", "/u/b/c/y/z/d/g");
+ assertMatches(expr.matcher("/a/b/c/e/g/@something"), "/a/b/c/e/g", "/u/b/c/y/z/e/g");
+ }
+
+ @Test
+ public void shouldMatchExpressionWithReoccurringNamedGroupsDollarsInOutputPath() {
+ expr = SequencerPathExpression.compile("/a/(b/c)[(d|e)/(f|g)/@something] => /u/$1/y/z/$2/$3/$1/$1");
+ assertMatches(expr.matcher("/a/b/c/d/f/@something"), "/a/b/c", "/u/b/c/y/z/d/f/b/c/b/c");
+ }
+
+ @Test
+ public void shouldMatchExpressionWithNamedGroupsAndEscapedDollarsInOutputPath() {
+ expr = SequencerPathExpression.compile("/a/(b/c)[(d|e)/(f|g)/@something] => /\\$2u/$1/y/z/$2/$3");
+ assertMatches(expr.matcher("/a/b/c/d/f/@something"), "/a/b/c", "/\\$2u/b/c/y/z/d/f");
+ }
+
+ @Test
+ public void shouldMatchExpressionWithParentReferencesInOutputPath() {
+ expr = SequencerPathExpression.compile("/a/b/c[d/e/@something] => /x/y/z/../..");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c", "/x");
+
+ expr = SequencerPathExpression.compile("/a/(b/c)[d/e/@something] => /x/$1/z/../../v");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c", "/x/b/v");
+ }
+
+ @Test
+ public void shouldMatchExpressionWithSelfReferencesInOutputPath() {
+ expr = SequencerPathExpression.compile("/a/b/c[d/e/@something] => /x/y/./z/.");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c", "/x/y/z");
+
+ expr = SequencerPathExpression.compile("/a/(b/c)[d/e/@something] => /x/$1/./z");
+ assertMatches(expr.matcher("/a/b/c/d/e/@something"), "/a/b/c", "/x/b/c/z");
+ }
+
+}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencingServiceTest.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencingServiceTest.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/SequencingServiceTest.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,331 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.jboss.dna.repository.sequencers;
+
+import java.util.concurrent.TimeUnit;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.hamcrest.core.IsSame.sameInstance;
+import static org.junit.Assert.assertThat;
+import static org.junit.matchers.JUnitMatchers.hasItem;
+import javax.jcr.Node;
+import javax.jcr.Session;
+import javax.jcr.observation.Event;
+import org.jboss.dna.common.jcr.AbstractJcrRepositoryTest;
+import org.jboss.dna.repository.observation.ObservationService;
+import org.jboss.dna.repository.sequencers.Sequencer;
+import org.jboss.dna.repository.sequencers.SequencerConfig;
+import org.jboss.dna.repository.sequencers.SequencingService;
+import org.jboss.dna.repository.services.ServiceAdministrator;
+import org.jboss.dna.repository.util.ExecutionContext;
+import org.jboss.dna.repository.util.SimpleExecutionContext;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author Randall Hauch
+ */
+public class SequencingServiceTest extends AbstractJcrRepositoryTest {
+
+ public static final int ALL_EVENT_TYPES = Event.NODE_ADDED | Event.NODE_REMOVED | Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED | Event.PROPERTY_REMOVED;
+ public static final String REPOSITORY_WORKSPACE_NAME = "testRepository-Workspace";
+
+ private ObservationService observationService;
+ private SequencingService sequencingService;
+ private ExecutionContext executionContext;
+
+ @Before
+ public void beforeEach() throws Exception {
+ this.executionContext = new SimpleExecutionContext(this, REPOSITORY_WORKSPACE_NAME);
+ this.sequencingService = new SequencingService();
+ this.sequencingService.setExecutionContext(this.executionContext);
+ this.observationService = new ObservationService(this.executionContext.getSessionFactory());
+ this.observationService.addListener(this.sequencingService);
+ }
+
+ @After
+ public void afterEach() throws Exception {
+ super.shutdownRepository();
+ this.sequencingService.getAdministrator().shutdown();
+ }
+
+ @Test
+ public void shouldHaveTheDefaultSelectorUponConstruction() {
+ assertThat(sequencingService.getSequencerSelector(), is(sameInstance(SequencingService.DEFAULT_SEQUENCER_SELECTOR)));
+ }
+
+ @Test
+ public void shouldHaveNoExecutorServiceUponConstruction() {
+ assertThat(sequencingService.getExecutorService(), is(nullValue()));
+ }
+
+ @Test
+ public void shouldCreateDefaultExecutorServiceWhenStartedIfNoExecutorServiceHasBeenSet() {
+ assertThat(sequencingService.getExecutorService(), is(nullValue()));
+ sequencingService.getAdministrator().start();
+ assertThat(sequencingService.getExecutorService(), is(notNullValue()));
+ }
+
+ @Test
+ public void shouldCreateExecutorServiceWhenStarted() {
+ assertThat(sequencingService.getExecutorService(), is(nullValue()));
+ sequencingService.getAdministrator().start();
+ assertThat(sequencingService.getExecutorService(), is(notNullValue()));
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldFailToSetStateToUnknownString() {
+ sequencingService.getAdministrator().setState("asdf");
+ }
+
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldFailToSetStateToNullString() {
+ sequencingService.getAdministrator().setState((String)null);
+ }
+
+ @Test
+ public void shouldSetStateUsingLowercaseString() {
+ assertThat(sequencingService.getAdministrator().setState("started").isStarted(), is(true));
+ assertThat(sequencingService.getAdministrator().setState("paused").isPaused(), is(true));
+ assertThat(sequencingService.getAdministrator().setState("shutdown").isShutdown(), is(true));
+ }
+
+ @Test
+ public void shouldSetStateUsingMixedCaseString() {
+ assertThat(sequencingService.getAdministrator().setState("StarTeD").isStarted(), is(true));
+ assertThat(sequencingService.getAdministrator().setState("PauSed").isPaused(), is(true));
+ assertThat(sequencingService.getAdministrator().setState("ShuTDowN").isShutdown(), is(true));
+ }
+
+ @Test
+ public void shouldSetStateUsingUppercasString() {
+ assertThat(sequencingService.getAdministrator().setState("STARTED").isStarted(), is(true));
+ assertThat(sequencingService.getAdministrator().setState("PAUSED").isPaused(), is(true));
+ assertThat(sequencingService.getAdministrator().setState("SHUTDOWN").isShutdown(), is(true));
+ }
+
+ @Test
+ public void shouldBePausedUponConstruction() {
+ assertThat(sequencingService.getAdministrator().isPaused(), is(true));
+ assertThat(sequencingService.getAdministrator().getState(), is(ServiceAdministrator.State.PAUSED));
+ assertThat(sequencingService.getAdministrator().isShutdown(), is(false));
+ assertThat(sequencingService.getAdministrator().isStarted(), is(false));
+ }
+
+ @Test
+ public void shouldBeAbleToShutdownWhenNotStarted() {
+ assertThat(sequencingService.getAdministrator().isShutdown(), is(false));
+ for (int i = 0; i != 3; ++i) {
+ assertThat(sequencingService.getAdministrator().shutdown().isShutdown(), is(true));
+ assertThat(sequencingService.getAdministrator().isPaused(), is(false));
+ assertThat(sequencingService.getAdministrator().isStarted(), is(false));
+ assertThat(sequencingService.getAdministrator().getState(), is(ServiceAdministrator.State.SHUTDOWN));
+ }
+ }
+
+ @Test
+ public void shouldBeAbleToBePauseAndRestarted() {
+ assertThat(sequencingService.getAdministrator().isShutdown(), is(false));
+ for (int i = 0; i != 3; ++i) {
+ // Now pause it ...
+ assertThat(sequencingService.getAdministrator().pause().isPaused(), is(true));
+ assertThat(sequencingService.getAdministrator().isStarted(), is(false));
+ assertThat(sequencingService.getAdministrator().isShutdown(), is(false));
+ assertThat(sequencingService.getAdministrator().getState(), is(ServiceAdministrator.State.PAUSED));
+
+ // Now start it back up ...
+ assertThat(sequencingService.getAdministrator().start().isStarted(), is(true));
+ assertThat(sequencingService.getAdministrator().isPaused(), is(false));
+ assertThat(sequencingService.getAdministrator().isShutdown(), is(false));
+ assertThat(sequencingService.getAdministrator().getState(), is(ServiceAdministrator.State.STARTED));
+ }
+ }
+
+ @Test( expected = IllegalStateException.class )
+ public void shouldNotBeAbleToBeRestartedAfterBeingShutdown() {
+ assertThat(sequencingService.getAdministrator().isShutdown(), is(false));
+ // Shut it down ...
+ assertThat(sequencingService.getAdministrator().shutdown().isShutdown(), is(true));
+ assertThat(sequencingService.getAdministrator().isPaused(), is(false));
+ assertThat(sequencingService.getAdministrator().isStarted(), is(false));
+ assertThat(sequencingService.getAdministrator().getState(), is(ServiceAdministrator.State.SHUTDOWN));
+
+ // Now start it back up ... this will fail
+ sequencingService.getAdministrator().start();
+ }
+
+ @Test
+ public void shouldBeAbleToMonitorWorkspaceWhenPausedOrStarted() throws Exception {
+ startRepository();
+ Session session = getRepository().login(getTestCredentials());
+
+ // Try when paused ...
+ assertThat(sequencingService.getAdministrator().isPaused(), is(true));
+ assertThat(observationService.getAdministrator().pause().isPaused(), is(true));
+ ObservationService.WorkspaceListener listener = observationService.monitor(REPOSITORY_WORKSPACE_NAME, Event.NODE_ADDED);
+ assertThat(listener, is(notNullValue()));
+ assertThat(listener.getAbsolutePath(), is("/"));
+ assertThat(listener.getEventTypes(), is(Event.NODE_ADDED));
+
+ // Cause an event ...
+ session.getRootNode().addNode("testnodeA", "nt:unstructured");
+ session.save();
+ Thread.sleep(100); // let the events be handled ...
+ assertThat(observationService.getStatistics().getNumberOfEventsIgnored(), is((long)1));
+
+ // Reset the statistics and remove the listener ...
+ sequencingService.getStatistics().reset();
+ observationService.getStatistics().reset();
+ assertThat(listener.isRegistered(), is(true));
+ listener.unregister();
+ assertThat(listener.isRegistered(), is(false));
+
+ // Start the sequencing sequencingService and try monitoring the workspace ...
+ assertThat(sequencingService.getAdministrator().start().isStarted(), is(true));
+ assertThat(observationService.getAdministrator().start().isStarted(), is(true));
+ ObservationService.WorkspaceListener listener2 = observationService.monitor(REPOSITORY_WORKSPACE_NAME, Event.NODE_ADDED);
+ assertThat(listener2.isRegistered(), is(true));
+ assertThat(listener2, is(notNullValue()));
+ assertThat(listener2.getAbsolutePath(), is("/"));
+ assertThat(listener2.getEventTypes(), is(Event.NODE_ADDED));
+
+ // Cause an event ...
+ session.getRootNode().addNode("testnodeB", "nt:unstructured");
+ session.save();
+ Thread.sleep(100); // let the events be handled ...
+
+ // Check the results: nothing ignored, and 1 node skipped (since no sequencers apply)
+ assertThat(observationService.getStatistics().getNumberOfEventsIgnored(), is((long)0));
+ assertThat(sequencingService.getStatistics().getNumberOfNodesSkipped(), is((long)1));
+
+ sequencingService.getAdministrator().shutdown();
+ sequencingService.getStatistics().reset();
+ observationService.getAdministrator().shutdown();
+ observationService.getStatistics().reset();
+
+ // Cause another event ...
+ session.getRootNode().addNode("testnodeC", "nt:unstructured");
+ session.save();
+ Thread.sleep(100); // let the events be handled ...
+ // The listener should no longer be registered ...
+ assertThat(listener2.isRegistered(), is(false));
+
+ // Check the results: nothing ignored, and nothing skipped
+ assertThat(observationService.getStatistics().getNumberOfEventsIgnored(), is((long)0));
+ assertThat(sequencingService.getStatistics().getNumberOfNodesSkipped(), is((long)0));
+ }
+
+ @Test
+ public void shouldUnregisterAllWorkspaceListenersWhenSystemIsShutdownAndNotWhenPaused() throws Exception {
+ startRepository();
+ Session session = getRepository().login(getTestCredentials());
+
+ // Start the sequencing sequencingService and try monitoring the workspace ...
+ assertThat(sequencingService.getAdministrator().start().isStarted(), is(true));
+ ObservationService.WorkspaceListener listener = observationService.monitor(REPOSITORY_WORKSPACE_NAME, Event.NODE_ADDED);
+ assertThat(listener.isRegistered(), is(true));
+ assertThat(listener, is(notNullValue()));
+ assertThat(listener.getAbsolutePath(), is("/"));
+ assertThat(listener.getEventTypes(), is(Event.NODE_ADDED));
+
+ // Cause an event ...
+ session.getRootNode().addNode("testnodeB", "nt:unstructured");
+ session.save();
+ assertThat(listener.isRegistered(), is(true));
+
+ // Pause the sequencingService, can cause an event ...
+ sequencingService.getAdministrator().pause();
+ session.getRootNode().addNode("testnodeB", "nt:unstructured");
+ session.save();
+ assertThat(listener.isRegistered(), is(true));
+
+ // Shut down the services and await termination ...
+ sequencingService.getAdministrator().shutdown();
+ observationService.getAdministrator().shutdown();
+ sequencingService.getAdministrator().awaitTermination(2, TimeUnit.SECONDS);
+ observationService.getAdministrator().awaitTermination(2, TimeUnit.SECONDS);
+
+ // Cause another event ...
+ session.getRootNode().addNode("testnodeC", "nt:unstructured");
+ session.save();
+
+ // The listener should no longer be registered ...
+ assertThat(listener.isRegistered(), is(false));
+ }
+
+ @Test
+ public void shouldExecuteSequencersUponChangesToRepositoryThatMatchSequencerPathExpressions() throws Exception {
+ // Add configurations for a sequencer ...
+ String name = "MockSequencerA";
+ String desc = "A mock sequencer that accumulates the number of times it's called";
+ String classname = MockSequencerA.class.getName();
+ String[] classpath = null;
+ String[] pathExpressions = {"/testnodeC/testnodeD/@description => ."};
+ SequencerConfig configA = new SequencerConfig(name, desc, classname, classpath, pathExpressions);
+ sequencingService.addSequencer(configA);
+
+ // Start the repository and get a session ...
+ startRepository();
+ Session session = getRepository().login(getTestCredentials());
+
+ // Start the sequencing sequencingService and try monitoring the workspace ...
+ assertThat(sequencingService.getAdministrator().start().isStarted(), is(true));
+ ObservationService.WorkspaceListener listener = observationService.monitor(REPOSITORY_WORKSPACE_NAME, ALL_EVENT_TYPES);
+ assertThat(listener.isRegistered(), is(true));
+ assertThat(listener, is(notNullValue()));
+ assertThat(listener.getAbsolutePath(), is("/"));
+ assertThat(listener.getEventTypes(), is(ALL_EVENT_TYPES));
+
+ // The sequencer should not yet have run ...
+ MockSequencerA sequencerA = (MockSequencerA)sequencingService.getSequencerLibrary().getInstances().get(0);
+ assertThat(sequencerA, is(notNullValue()));
+ assertThat(sequencerA.getCounter(), is(0));
+ assertThat(sequencingService.getSequencerLibrary().getInstances(), hasItem((Sequencer)sequencerA));
+
+ // Cause an event, but not one that the sequencer cares about ...
+ Node nodeC = session.getRootNode().addNode("testnodeC", "nt:unstructured");
+ assertThat(nodeC, is(notNullValue()));
+ session.save();
+ assertThat(sequencerA.getCounter(), is(0));
+ assertThat(sequencingService.getSequencerLibrary().getInstances(), hasItem((Sequencer)sequencerA));
+
+ // Cause another event, but again one that the sequencer does not care about ...
+ Node nodeD = nodeC.addNode("testnodeD", "nt:unstructured");
+ assertThat(nodeD, is(notNullValue()));
+ session.save();
+ assertThat(sequencerA.getCounter(), is(0));
+ assertThat(sequencingService.getSequencerLibrary().getInstances(), hasItem((Sequencer)sequencerA));
+
+ // Now set the property that the sequencer DOES care about ...
+ sequencerA.setExpectedCount(1);
+ nodeD.setProperty("description", "This is the value");
+ session.save();
+
+ // Wait for the event to be processed and the sequencer to be called ...
+ sequencerA.awaitExecution(4, TimeUnit.SECONDS); // wait for the sequencer to be called
+ assertThat(sequencerA.getCounter(), is(1));
+ assertThat(sequencingService.getSequencerLibrary().getInstances(), hasItem((Sequencer)sequencerA));
+ }
+}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/StreamSequencerAdapterTest.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/StreamSequencerAdapterTest.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/sequencers/StreamSequencerAdapterTest.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,336 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.sequencers;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.hamcrest.core.IsSame.sameInstance;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import javax.jcr.Node;
+import javax.jcr.Session;
+import javax.jcr.observation.Event;
+import org.jboss.dna.common.jcr.AbstractJcrRepositoryTest;
+import org.jboss.dna.common.monitor.ProgressMonitor;
+import org.jboss.dna.common.monitor.RecordingProgressMonitor;
+import org.jboss.dna.repository.observation.NodeChange;
+import org.jboss.dna.repository.sequencers.SequencerConfig;
+import org.jboss.dna.repository.sequencers.SequencerException;
+import org.jboss.dna.repository.sequencers.SequencerOutputMap;
+import org.jboss.dna.repository.sequencers.StreamSequencerAdapter;
+import org.jboss.dna.repository.util.ExecutionContext;
+import org.jboss.dna.repository.util.JcrTools;
+import org.jboss.dna.repository.util.RepositoryNodePath;
+import org.jboss.dna.repository.util.SessionFactory;
+import org.jboss.dna.spi.sequencers.SequencerOutput;
+import org.jboss.dna.spi.sequencers.StreamSequencer;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author Randall Hauch
+ */
+public class StreamSequencerAdapterTest extends AbstractJcrRepositoryTest {
+
+ private StreamSequencer streamSequencer;
+ private StreamSequencerAdapter sequencer;
+ private String[] validExpressions = {"/a/* => /output"};
+ private SequencerConfig validConfig = new SequencerConfig("name", "desc", "something.class", null, validExpressions);
+ private JcrTools tools;
+ private Session session;
+ private SequencerOutputMap sequencerOutput;
+ private String sampleData = "The little brown fox didn't something bad.";
+ private ExecutionContext context;
+ private RecordingProgressMonitor progressMonitor;
+ private String repositoryWorkspaceName = "something";
+
+ @Before
+ public void beforeEach() throws Exception {
+ final JcrTools tools = new JcrTools();
+ this.tools = tools;
+ sequencerOutput = new SequencerOutputMap();
+ progressMonitor = new RecordingProgressMonitor(StreamSequencerAdapterTest.class.getName());
+ final SessionFactory sessionFactory = new SessionFactory() {
+
+ public Session createSession( String name ) {
+ return createTestSession();
+ }
+ };
+ context = new ExecutionContext() {
+
+ public SessionFactory getSessionFactory() {
+ return sessionFactory;
+ }
+
+ public JcrTools getTools() {
+ return tools;
+ }
+ };
+ final SequencerOutputMap finalOutput = sequencerOutput;
+ streamSequencer = new StreamSequencer() {
+
+ /**
+ * This method always copies the {@link StreamSequencerAdapterTest#sequencerOutput} data into the output {@inheritDoc},
+ * and does nothing else with any of the other parameters.
+ */
+ public void sequence( InputStream stream, SequencerOutput output, ProgressMonitor progressMonitor ) {
+ for (SequencerOutputMap.Entry entry : finalOutput) {
+ String nodePath = entry.getPath().getString();
+ for (SequencerOutputMap.PropertyValue property : entry.getPropertyValues()) {
+ output.setProperty(nodePath, property.getName(), property.getValue());
+ }
+ }
+ }
+ };
+ sequencer = new StreamSequencerAdapter(streamSequencer);
+ }
+
+ @After
+ public void afterEach() throws Exception {
+ if (session != null) {
+ try {
+ session.logout();
+ } finally {
+ session = null;
+ }
+ }
+ }
+
+ protected Session createTestSession() {
+ try {
+ return getRepository().login(getTestCredentials());
+ } catch (Exception e) {
+ fail("Unable to create repository session: " + e.getMessage());
+ return null; // won't get here
+ }
+ }
+
+ @Test
+ public void shouldNotHaveSequencerUponInstantiation() {
+ assertThat(sequencer.getConfiguration(), is(nullValue()));
+ sequencer.setConfiguration(validConfig);
+ assertThat(sequencer.getConfiguration(), is(sameInstance(validConfig)));
+ }
+
+ @Test
+ public void shouldExtractNullMixinTypesFromNullValue() {
+ assertThat(sequencer.extractMixinTypes(null), is(nullValue()));
+ }
+
+ @Test
+ public void shouldExtractMixinTypesFromStringValue() {
+ assertThat(sequencer.extractMixinTypes("value"), is(new String[] {"value"}));
+ assertThat(sequencer.extractMixinTypes(""), is(new String[] {""}));
+ }
+
+ @Test
+ public void shouldExtractMixinTypesFromStringArrayValue() {
+ assertThat(sequencer.extractMixinTypes(new String[] {"value1"}), is(new String[] {"value1"}));
+ assertThat(sequencer.extractMixinTypes(new String[] {"value1", "value2"}), is(new String[] {"value1", "value2"}));
+ }
+
+ @Test
+ public void shouldExtractMixinTypesFromStringArrayWithNullValue() {
+ assertThat(sequencer.extractMixinTypes(new String[] {"value1", null, "value2"}), is(new String[] {"value1", null, "value2"}));
+ }
+
+ @Test
+ public void shouldExecuteSequencerOnExistingNodeAndOutputToExistingNode() throws Exception {
+ startRepository();
+ session = getRepository().login(getTestCredentials());
+
+ // Set up the repository for the test ...
+ Node nodeC = tools.findOrCreateNode(session, "/a/b/c");
+ Node nodeE = tools.findOrCreateNode(session, "/d/e");
+ assertThat(nodeC, is(notNullValue()));
+ assertThat(nodeE, is(notNullValue()));
+ assertThat(nodeE.getNodes().getSize(), is(0l));
+ assertThat(nodeE.getProperties().getSize(), is(1l)); // jcr:primaryType
+ assertThat(nodeE.getProperty("jcr:primaryType").getString(), is("nt:unstructured"));
+
+ // Set the property that will be sequenced ...
+ nodeC.setProperty("sequencedProperty", new ByteArrayInputStream(sampleData.getBytes()));
+
+ // Set up the node changes ...
+ NodeChange nodeChange = new NodeChange(repositoryWorkspaceName, nodeC.getPath(), Event.PROPERTY_CHANGED, Collections.singleton("sequencedProperty"), null);
+
+ // Set up the output directory ...
+ Set<RepositoryNodePath> outputPaths = new HashSet<RepositoryNodePath>();
+ outputPaths.add(new RepositoryNodePath(repositoryWorkspaceName, nodeE.getPath()));
+
+ // Generate the output data that the sequencer subclass will produce and that should be saved to the repository ...
+ sequencerOutput.setProperty("alpha/beta", "isSomething", true);
+
+ // Call the sequencer ...
+ sequencer.execute(nodeC, "sequencedProperty", nodeChange, outputPaths, context, progressMonitor);
+ }
+
+ @Test( expected = SequencerException.class )
+ public void shouldExecuteSequencerOnExistingNodeWithMissingSequencedPropertyAndOutputToExistingNode() throws Exception {
+ startRepository();
+ session = getRepository().login(getTestCredentials());
+
+ // Set up the repository for the test ...
+ Node nodeC = tools.findOrCreateNode(session, "/a/b/c");
+ Node nodeE = tools.findOrCreateNode(session, "/d/e");
+ assertThat(nodeC, is(notNullValue()));
+ assertThat(nodeE, is(notNullValue()));
+ assertThat(nodeE.getNodes().getSize(), is(0l));
+ assertThat(nodeE.getProperties().getSize(), is(1l)); // jcr:primaryType
+ assertThat(nodeE.getProperty("jcr:primaryType").getString(), is("nt:unstructured"));
+
+ // Set the property that will be sequenced ...
+ // THIS TEST REQUIRES THIS PROPERTY TO BE NULL OR NON-EXISTANT
+ nodeC.setProperty("sequencedProperty", (InputStream)null);
+
+ // Set up the node changes ...
+ NodeChange nodeChange = new NodeChange(repositoryWorkspaceName, nodeC.getPath(), Event.PROPERTY_CHANGED, Collections.singleton("sequencedProperty"), null);
+
+ // Set up the output directory ...
+ Set<RepositoryNodePath> outputPaths = new HashSet<RepositoryNodePath>();
+ outputPaths.add(new RepositoryNodePath(repositoryWorkspaceName, nodeE.getPath()));
+
+ // Generate the output data that the sequencer subclass will produce and that should be saved to the repository ...
+ sequencerOutput.setProperty("alpha/beta", "isSomething", true);
+
+ // Call the sequencer, which should cause the exception ...
+ sequencer.execute(nodeC, "sequencedProperty", nodeChange, outputPaths, context, progressMonitor);
+ }
+
+ @Test
+ public void shouldExecuteSequencerOnExistingNodeAndOutputToMultipleExistingNodes() throws Exception {
+ startRepository();
+ session = getRepository().login(getTestCredentials());
+
+ // Set up the repository for the test ...
+ Node nodeC = tools.findOrCreateNode(session, "/a/b/c");
+ Node nodeE = tools.findOrCreateNode(session, "/d/e");
+ assertThat(nodeC, is(notNullValue()));
+ assertThat(nodeE, is(notNullValue()));
+ assertThat(nodeE.getNodes().getSize(), is(0l));
+ assertThat(nodeE.getProperties().getSize(), is(1l)); // jcr:primaryType
+ assertThat(nodeE.getProperty("jcr:primaryType").getString(), is("nt:unstructured"));
+
+ // Set the property that will be sequenced ...
+ nodeC.setProperty("sequencedProperty", new ByteArrayInputStream(sampleData.getBytes()));
+
+ // Set up the node changes ...
+ NodeChange nodeChange = new NodeChange(repositoryWorkspaceName, nodeC.getPath(), Event.PROPERTY_CHANGED, Collections.singleton("sequencedProperty"), null);
+
+ // Set up the output directory ...
+ Set<RepositoryNodePath> outputPaths = new HashSet<RepositoryNodePath>();
+ outputPaths.add(new RepositoryNodePath(repositoryWorkspaceName, "/d/e"));
+ outputPaths.add(new RepositoryNodePath(repositoryWorkspaceName, "/x/y/z"));
+
+ // Generate the output data that the sequencer subclass will produce and that should be saved to the repository ...
+ sequencerOutput.setProperty("alpha/beta", "isSomething", true);
+
+ // Call the sequencer ...
+ sequencer.execute(nodeC, "sequencedProperty", nodeChange, outputPaths, context, progressMonitor);
+
+ // Check to see that the output nodes have been created ...
+ assertThat(session.getRootNode().hasNode("d/e"), is(true));
+ assertThat(session.getRootNode().hasNode("x/y/z"), is(true));
+ }
+
+ @Test
+ public void shouldExecuteSequencerOnExistingNodeAndOutputToNonExistingNode() throws Exception {
+ startRepository();
+ session = getRepository().login(getTestCredentials());
+
+ // Set up the repository for the test ...
+ Node nodeC = tools.findOrCreateNode(session, "/a/b/c");
+ assertThat(session.getRootNode().hasNode("d"), is(false));
+ assertThat(nodeC, is(notNullValue()));
+
+ // Set the property that will be sequenced ...
+ nodeC.setProperty("sequencedProperty", new ByteArrayInputStream(sampleData.getBytes()));
+
+ // Set up the node changes ...
+ NodeChange nodeChange = new NodeChange(repositoryWorkspaceName, nodeC.getPath(), Event.PROPERTY_CHANGED, Collections.singleton("sequencedProperty"), null);
+
+ // Set up the output directory ...
+ Set<RepositoryNodePath> outputPaths = new HashSet<RepositoryNodePath>();
+ outputPaths.add(new RepositoryNodePath(repositoryWorkspaceName, "/d/e"));
+
+ // Generate the output data that the sequencer subclass will produce and that should be saved to the repository ...
+ sequencerOutput.setProperty("alpha/beta", "isSomething", true);
+
+ // Call the sequencer ...
+ sequencer.execute(nodeC, "sequencedProperty", nodeChange, outputPaths, context, progressMonitor);
+
+ // Check to see that the "/d/e" node has been created ...
+ assertThat(session.getRootNode().hasNode("d/e"), is(true));
+ }
+
+ @Test
+ public void shouldExecuteSequencerOnExistingNodeAndOutputToMultipleNonExistingNodes() throws Exception {
+ startRepository();
+ session = getRepository().login(getTestCredentials());
+
+ // Set up the repository for the test ...
+ Node nodeC = tools.findOrCreateNode(session, "/a/b/c");
+ assertThat(session.getRootNode().hasNode("d"), is(false));
+ assertThat(session.getRootNode().hasNode("x"), is(false));
+ assertThat(nodeC, is(notNullValue()));
+
+ // Set the property that will be sequenced ...
+ nodeC.setProperty("sequencedProperty", new ByteArrayInputStream(sampleData.getBytes()));
+
+ // Set up the node changes ...
+ NodeChange nodeChange = new NodeChange(repositoryWorkspaceName, nodeC.getPath(), Event.PROPERTY_CHANGED, Collections.singleton("sequencedProperty"), null);
+
+ // Set up the output directory ...
+ Set<RepositoryNodePath> outputPaths = new HashSet<RepositoryNodePath>();
+ outputPaths.add(new RepositoryNodePath(repositoryWorkspaceName, "/d/e"));
+ outputPaths.add(new RepositoryNodePath(repositoryWorkspaceName, "/x/y/z"));
+ outputPaths.add(new RepositoryNodePath(repositoryWorkspaceName, "/x/z"));
+
+ // Generate the output data that the sequencer subclass will produce and that should be saved to the repository ...
+ sequencerOutput.setProperty("alpha/beta", "isSomething", true);
+
+ // Call the sequencer ...
+ sequencer.execute(nodeC, "sequencedProperty", nodeChange, outputPaths, context, progressMonitor);
+
+ // Check to see that the output nodes have been created ...
+ assertThat(session.getRootNode().hasNode("d/e"), is(true));
+ assertThat(session.getRootNode().hasNode("x/y/z"), is(true));
+ assertThat(session.getRootNode().hasNode("x/z"), is(true));
+
+ // Check to see that the sequencer-generated nodes have been created ...
+ // Node beta = session.getRootNode().getNode("d/e/alpha/beta");
+ // for (PropertyIterator iter = beta.getProperties(); iter.hasNext();) {
+ // Property property = iter.nextProperty();
+ // System.out.println("Property on " + beta.getPath() + " ===> " + property.getName() + " = " + property.getValue());
+ // }
+ assertThat(session.getRootNode().getNode("d/e/alpha/beta").getProperty("isSomething").getBoolean(), is(true));
+ assertThat(session.getRootNode().getNode("x/y/z/alpha/beta").getProperty("isSomething").getBoolean(), is(true));
+ assertThat(session.getRootNode().getNode("x/z/alpha/beta").getProperty("isSomething").getBoolean(), is(true));
+ }
+}
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/util/JndiSessionFactoryTest.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/util/JndiSessionFactoryTest.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/util/JndiSessionFactoryTest.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,168 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.util;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.hamcrest.core.IsSame.sameInstance;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import javax.jcr.Repository;
+import javax.jcr.Session;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import org.jboss.dna.common.SystemFailureException;
+import org.jboss.dna.common.jcr.AbstractJcrRepositoryTest;
+import org.jboss.dna.common.naming.MockInitialContext;
+import org.jboss.dna.repository.util.JndiSessionFactory;
+import org.jmock.Mockery;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author Randall Hauch
+ */
+public class JndiSessionFactoryTest extends AbstractJcrRepositoryTest {
+
+ public static final String MOCK_REPOSITORY_NAME = "java:jcr/unit/test/repository/1";
+ public static final String MOCK_REPOSITORY_NAME_ALT = "java:jcr/unit/test/repository/2";
+
+ private JndiSessionFactory factory;
+ private Mockery context;
+ private Repository mockRepository;
+ private Session session;
+
+ @Before
+ public void beforeEach() throws Exception {
+ this.context = new Mockery();
+ this.mockRepository = this.context.mock(Repository.class);
+ MockInitialContext.register(MOCK_REPOSITORY_NAME, this.mockRepository);
+ this.factory = new JndiSessionFactory();
+ }
+
+ @After
+ public void afterEach() throws Exception {
+ if (session != null) {
+ session.logout();
+ }
+ MockInitialContext.tearDown();
+ }
+
+ protected void assertNotRegistered( String name ) {
+ try {
+ new InitialContext().lookup(name);
+ fail("Unexpectedly found registered object");
+ } catch (NamingException e) {
+ // expected ...
+ }
+ }
+
+ protected void assertRegistered( String name, Object obj ) {
+ try {
+ assertThat(new InitialContext().lookup(name), is(sameInstance(obj)));
+ } catch (NamingException e) {
+ fail("Failed to find registered object \"" + name + "\"");
+ }
+ }
+
+ @Test
+ public void shouldCreateSessionForRegisteredRepository() {
+
+ }
+
+ @Test( expected = SystemFailureException.class )
+ public void shouldThrowSystemFailureWhenUnableToFindRegisteredRepository() throws Exception {
+ factory.createSession(MOCK_REPOSITORY_NAME + "something_extra_that_can't_be_found");
+ }
+
+ @Test
+ public void shouldFindWorkspaceInRegisteredName() {
+ assertThat(factory.getWorkspaceName("java:jcr/path/to/repository/workspaceName"), is("workspaceName"));
+ }
+
+ @Test
+ public void shouldReturnNullWorkspaceIfRegisteredNameEndsInDelimiter() {
+ assertThat(factory.getWorkspaceName("java:jcr/path/to/repository/"), is(nullValue()));
+ }
+
+ @Test
+ public void shouldReturnNullWorkspaceIfRegisteredNameHasNoDelimiter() {
+ assertThat(factory.getWorkspaceName("java:jcr"), is(nullValue()));
+ }
+
+ @Test
+ public void shouldFindRepositoryInRegisteredName() {
+ assertThat(factory.getRepositoryName("java:jcr/path/to/repository/workspaceName"), is("java:jcr/path/to/repository"));
+ }
+
+ @Test
+ public void shouldConsiderWholeRegisteredNameToBeRepositoryNameIfRegisteredNameEndsInDelimiter() {
+ assertThat(factory.getRepositoryName("java:jcr/path/to/repository/"), is("java:jcr/path/to/repository"));
+ }
+
+ @Test
+ public void shouldConsiderWholeRegisteredNameToBeRepositoryNameIfRegisteredNameHasNoDelimiter() {
+ assertThat(factory.getRepositoryName("java:jcr"), is("java:jcr"));
+ }
+
+ @Test
+ public void shouldRegisterSuppliedRepositoryInJndi() throws Exception {
+ assertNotRegistered(MOCK_REPOSITORY_NAME_ALT);
+ factory.registerRepository(MOCK_REPOSITORY_NAME_ALT, mockRepository);
+ assertRegistered(MOCK_REPOSITORY_NAME_ALT, mockRepository);
+ }
+
+ @Test
+ public void shouldUnregisterRepositoryInJndiIfNullRepositoryReference() throws Exception {
+ assertRegistered(MOCK_REPOSITORY_NAME, mockRepository);
+ factory.registerRepository(MOCK_REPOSITORY_NAME, null);
+ assertNotRegistered(MOCK_REPOSITORY_NAME);
+ }
+
+ @Test
+ public void shouldRemoveAllTrailingDelimitersWhenRegisteringRepository() throws Exception {
+ assertNotRegistered("java:jcr/unit/test/repository");
+ factory.registerRepository("java:jcr/unit/test/repository///", mockRepository);
+ assertRegistered("java:jcr/unit/test/repository", mockRepository);
+ }
+
+ @Test
+ public void shouldCreateAnonymousSessionInRepositoryIfNoCredentialsAreRegisterd() throws Exception {
+ Repository repository = getRepository();
+ factory.registerRepository("java:jcr/unit/test/repository/", repository);
+ session = factory.createSession("java:jcr/unit/test/repository/default");
+ assertThat(session, is(notNullValue()));
+ assertThat(session.getUserID(), is("anonymous")); // as defined in the Jackrabbit configuration file
+ }
+
+ @Test
+ public void shouldCreateNonAnonymousSessionInRepositoryIfCredentialsAreRegistered() throws Exception {
+ Repository repository = getRepository();
+ factory.registerRepository("java:jcr/unit/test/repository/", repository);
+ factory.registerCredentials("java:jcr/unit/test/repository/default", "jsmith", "secret".toCharArray());
+ session = factory.createSession("java:jcr/unit/test/repository/default");
+ assertThat(session, is(notNullValue()));
+ assertThat(session.getUserID(), is("jsmith")); // as defined in the Jackrabbit configuration file
+ }
+}
Property changes on: trunk/dna-repository/src/test/java/org/jboss/dna/repository/util/JndiSessionFactoryTest.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/dna-repository/src/test/java/org/jboss/dna/repository/util/SimpleExecutionContext.java
===================================================================
--- trunk/dna-repository/src/test/java/org/jboss/dna/repository/util/SimpleExecutionContext.java (rev 0)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/repository/util/SimpleExecutionContext.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,67 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.repository.util;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+import java.io.IOException;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import org.jboss.dna.common.SystemFailureException;
+import org.jboss.dna.common.jcr.AbstractJcrRepositoryTest;
+import org.jboss.dna.repository.util.ExecutionContext;
+import org.jboss.dna.repository.util.JcrTools;
+import org.jboss.dna.repository.util.SessionFactory;
+
+/**
+ * @author Randall Hauch
+ */
+public class SimpleExecutionContext implements ExecutionContext {
+
+ private JcrTools tools = new JcrTools();
+ private SessionFactory sessionFactory;
+
+ public SimpleExecutionContext( final AbstractJcrRepositoryTest test, final String repositoryName ) {
+ this.sessionFactory = new SessionFactory() {
+
+ public Session createSession( String name ) throws RepositoryException {
+ assertThat(name, is(repositoryName));
+ try {
+ return test.getRepository().login(test.getTestCredentials());
+ } catch (IOException e) {
+ throw new SystemFailureException(e);
+ }
+ }
+ };
+ }
+
+ public SessionFactory getSessionFactory() {
+ return sessionFactory;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public JcrTools getTools() {
+ return tools;
+ }
+}
Property changes on: trunk/dna-repository/src/test/java/org/jboss/dna/repository/util/SimpleExecutionContext.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Deleted: trunk/dna-repository/src/test/java/org/jboss/dna/services/JndiSessionFactoryTest.java
===================================================================
--- trunk/dna-services/src/test/java/org/jboss/dna/services/JndiSessionFactoryTest.java 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/services/JndiSessionFactoryTest.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,167 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source.
- * Copyright 2008, Red Hat Middleware LLC, and individual contributors
- * as indicated by the @author tags. See the copyright.txt file in the
- * distribution for a full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-package org.jboss.dna.services;
-
-import static org.hamcrest.core.Is.is;
-import static org.hamcrest.core.IsNull.notNullValue;
-import static org.hamcrest.core.IsNull.nullValue;
-import static org.hamcrest.core.IsSame.sameInstance;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-import javax.jcr.Repository;
-import javax.jcr.Session;
-import javax.naming.InitialContext;
-import javax.naming.NamingException;
-import org.jboss.dna.common.SystemFailureException;
-import org.jboss.dna.common.jcr.AbstractJcrRepositoryTest;
-import org.jboss.dna.common.naming.MockInitialContext;
-import org.jmock.Mockery;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-/**
- * @author Randall Hauch
- */
-public class JndiSessionFactoryTest extends AbstractJcrRepositoryTest {
-
- public static final String MOCK_REPOSITORY_NAME = "java:jcr/unit/test/repository/1";
- public static final String MOCK_REPOSITORY_NAME_ALT = "java:jcr/unit/test/repository/2";
-
- private JndiSessionFactory factory;
- private Mockery context;
- private Repository mockRepository;
- private Session session;
-
- @Before
- public void beforeEach() throws Exception {
- this.context = new Mockery();
- this.mockRepository = this.context.mock(Repository.class);
- MockInitialContext.register(MOCK_REPOSITORY_NAME, this.mockRepository);
- this.factory = new JndiSessionFactory();
- }
-
- @After
- public void afterEach() throws Exception {
- if (session != null) {
- session.logout();
- }
- MockInitialContext.tearDown();
- }
-
- protected void assertNotRegistered( String name ) {
- try {
- new InitialContext().lookup(name);
- fail("Unexpectedly found registered object");
- } catch (NamingException e) {
- // expected ...
- }
- }
-
- protected void assertRegistered( String name, Object obj ) {
- try {
- assertThat(new InitialContext().lookup(name), is(sameInstance(obj)));
- } catch (NamingException e) {
- fail("Failed to find registered object \"" + name + "\"");
- }
- }
-
- @Test
- public void shouldCreateSessionForRegisteredRepository() {
-
- }
-
- @Test( expected = SystemFailureException.class )
- public void shouldThrowSystemFailureWhenUnableToFindRegisteredRepository() throws Exception {
- factory.createSession(MOCK_REPOSITORY_NAME + "something_extra_that_can't_be_found");
- }
-
- @Test
- public void shouldFindWorkspaceInRegisteredName() {
- assertThat(factory.getWorkspaceName("java:jcr/path/to/repository/workspaceName"), is("workspaceName"));
- }
-
- @Test
- public void shouldReturnNullWorkspaceIfRegisteredNameEndsInDelimiter() {
- assertThat(factory.getWorkspaceName("java:jcr/path/to/repository/"), is(nullValue()));
- }
-
- @Test
- public void shouldReturnNullWorkspaceIfRegisteredNameHasNoDelimiter() {
- assertThat(factory.getWorkspaceName("java:jcr"), is(nullValue()));
- }
-
- @Test
- public void shouldFindRepositoryInRegisteredName() {
- assertThat(factory.getRepositoryName("java:jcr/path/to/repository/workspaceName"), is("java:jcr/path/to/repository"));
- }
-
- @Test
- public void shouldConsiderWholeRegisteredNameToBeRepositoryNameIfRegisteredNameEndsInDelimiter() {
- assertThat(factory.getRepositoryName("java:jcr/path/to/repository/"), is("java:jcr/path/to/repository"));
- }
-
- @Test
- public void shouldConsiderWholeRegisteredNameToBeRepositoryNameIfRegisteredNameHasNoDelimiter() {
- assertThat(factory.getRepositoryName("java:jcr"), is("java:jcr"));
- }
-
- @Test
- public void shouldRegisterSuppliedRepositoryInJndi() throws Exception {
- assertNotRegistered(MOCK_REPOSITORY_NAME_ALT);
- factory.registerRepository(MOCK_REPOSITORY_NAME_ALT, mockRepository);
- assertRegistered(MOCK_REPOSITORY_NAME_ALT, mockRepository);
- }
-
- @Test
- public void shouldUnregisterRepositoryInJndiIfNullRepositoryReference() throws Exception {
- assertRegistered(MOCK_REPOSITORY_NAME, mockRepository);
- factory.registerRepository(MOCK_REPOSITORY_NAME, null);
- assertNotRegistered(MOCK_REPOSITORY_NAME);
- }
-
- @Test
- public void shouldRemoveAllTrailingDelimitersWhenRegisteringRepository() throws Exception {
- assertNotRegistered("java:jcr/unit/test/repository");
- factory.registerRepository("java:jcr/unit/test/repository///", mockRepository);
- assertRegistered("java:jcr/unit/test/repository", mockRepository);
- }
-
- @Test
- public void shouldCreateAnonymousSessionInRepositoryIfNoCredentialsAreRegisterd() throws Exception {
- Repository repository = getRepository();
- factory.registerRepository("java:jcr/unit/test/repository/", repository);
- session = factory.createSession("java:jcr/unit/test/repository/default");
- assertThat(session, is(notNullValue()));
- assertThat(session.getUserID(), is("anonymous")); // as defined in the Jackrabbit configuration file
- }
-
- @Test
- public void shouldCreateNonAnonymousSessionInRepositoryIfCredentialsAreRegistered() throws Exception {
- Repository repository = getRepository();
- factory.registerRepository("java:jcr/unit/test/repository/", repository);
- factory.registerCredentials("java:jcr/unit/test/repository/default", "jsmith", "secret".toCharArray());
- session = factory.createSession("java:jcr/unit/test/repository/default");
- assertThat(session, is(notNullValue()));
- assertThat(session.getUserID(), is("jsmith")); // as defined in the Jackrabbit configuration file
- }
-}
Deleted: trunk/dna-repository/src/test/java/org/jboss/dna/services/SimpleExecutionContext.java
===================================================================
--- trunk/dna-services/src/test/java/org/jboss/dna/services/SimpleExecutionContext.java 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/test/java/org/jboss/dna/services/SimpleExecutionContext.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,65 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source.
- * Copyright 2008, Red Hat Middleware LLC, and individual contributors
- * as indicated by the @author tags. See the copyright.txt file in the
- * distribution for a full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-package org.jboss.dna.services;
-
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-import java.io.IOException;
-import javax.jcr.RepositoryException;
-import javax.jcr.Session;
-import org.jboss.dna.common.SystemFailureException;
-import org.jboss.dna.common.jcr.AbstractJcrRepositoryTest;
-import org.jboss.dna.services.util.JcrTools;
-
-/**
- * @author Randall Hauch
- */
-public class SimpleExecutionContext implements ExecutionContext {
-
- private JcrTools tools = new JcrTools();
- private SessionFactory sessionFactory;
-
- public SimpleExecutionContext( final AbstractJcrRepositoryTest test, final String repositoryName ) {
- this.sessionFactory = new SessionFactory() {
-
- public Session createSession( String name ) throws RepositoryException {
- assertThat(name, is(repositoryName));
- try {
- return test.getRepository().login(test.getTestCredentials());
- } catch (IOException e) {
- throw new SystemFailureException(e);
- }
- }
- };
- }
-
- public SessionFactory getSessionFactory() {
- return sessionFactory;
- }
-
- /**
- * {@inheritDoc}
- */
- public JcrTools getTools() {
- return tools;
- }
-}
Modified: trunk/dna-repository/src/test/resources/log4j.properties
===================================================================
--- trunk/dna-services/src/test/resources/log4j.properties 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/test/resources/log4j.properties 2008-04-22 02:47:53 UTC (rev 96)
@@ -9,7 +9,7 @@
# Set up the default logging to be INFO level, then override specific units
log4j.logger.org.jboss.dna=INFO
-log4j.logger.org.jboss.dna.services.sequencers=TRACE
+log4j.logger.org.jboss.dna.repository.sequencers=TRACE
# Jackrabbit logging
log4j.logger.org.apache.jackrabbit=WARN, stdout
Modified: trunk/dna-repository/src/test/resources/rule_test.dslr
===================================================================
--- trunk/dna-services/src/test/resources/rule_test.dslr 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/dna-repository/src/test/resources/rule_test.dslr 2008-04-22 02:47:53 UTC (rev 96)
@@ -1,5 +1,5 @@
#created on: Jan 4, 2008
-package org.jboss.dna.services.rules
+package org.jboss.dna.repository.rules
#list any import classes here.
Property changes on: trunk/dna-spi
___________________________________________________________________
Name: svn:ignore
+ target
Added: trunk/dna-spi/.classpath
===================================================================
--- trunk/dna-spi/.classpath (rev 0)
+++ trunk/dna-spi/.classpath 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src/main/java"/>
+ <classpathentry kind="src" path="src/main/resources"/>
+ <classpathentry kind="src" output="target/test-classes" path="src/test/java"/>
+ <classpathentry kind="src" output="target/test-classes" path="src/test/resources"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+ <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/>
+ <classpathentry kind="output" path="target/classes"/>
+</classpath>
Added: trunk/dna-spi/.project
===================================================================
--- trunk/dna-spi/.project (rev 0)
+++ trunk/dna-spi/.project 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>dna-spi</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.maven.ide.eclipse.maven2Builder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.maven.ide.eclipse.maven2Nature</nature>
+ </natures>
+</projectDescription>
Added: trunk/dna-spi/pom.xml
===================================================================
--- trunk/dna-spi/pom.xml (rev 0)
+++ trunk/dna-spi/pom.xml 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8"?><project>
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.jboss.dna</groupId>
+ <artifactId>dna</artifactId>
+ <version>0.1-SNAPSHOT</version>
+ </parent>
+ <!-- The groupId and version values are inherited from parent -->
+ <artifactId>dna-spi</artifactId>
+ <description>The JBoss DNA Service Provider Interface (SPI) used to create extensions</description>
+ <packaging>jar</packaging>
+ <name>JBoss DNA Service Provider Interface (SPI)</name>
+ <url>http://labs.jboss.org/dna</url>
+ <!--
+ Define the dependencies. Note that all version and scopes default to those
+ defined in the dependencyManagement section of the parent pom.
+ -->
+ <dependencies>
+ <dependency>
+ <groupId>org.jboss.dna</groupId>
+ <artifactId>dna-common</artifactId>
+ <version>0.1-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.jboss.dna</groupId>
+ <artifactId>dna-common</artifactId>
+ <version>0.1-SNAPSHOT</version>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
+ <!--
+ Testing (note the scope)
+ -->
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.jmock</groupId>
+ <artifactId>jmock</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.jmock</groupId>
+ <artifactId>jmock-junit4</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <!--
+ Logging (require SLF4J API for compiling, but use Log4J and its SLF4J binding for testing)
+ -->
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-log4j12</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>log4j</groupId>
+ <artifactId>log4j</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <!--
+ Java Concurrency in Practice annotations
+ -->
+ <dependency>
+ <groupId>net.jcip</groupId>
+ <artifactId>jcip-annotations</artifactId>
+ </dependency>
+ </dependencies>
+</project>
Added: trunk/dna-spi/src/main/java/org/jboss/dna/spi/sequencers/SequencerOutput.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/sequencers/SequencerOutput.java (rev 0)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/sequencers/SequencerOutput.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,68 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.spi.sequencers;
+
+import java.io.InputStream;
+import java.util.Calendar;
+
+/**
+ * Interface for sequencers to use to generate their output.
+ *
+ * @author Randall Hauch
+ */
+public interface SequencerOutput {
+
+ /**
+ * Set the supplied property on the supplied node.
+ * <p>
+ * The allowable values are any of the following:
+ * <ul>
+ * <li>primitives (which will be autoboxed)</li>
+ * <li>{@link String} instances</li>
+ * <li>{@link String} arrays</li>
+ * <li>byte arrays</li>
+ * <li>{@link InputStream} instances</li>
+ * <li>{@link Calendar} instances</li>
+ * <li></li>
+ * </ul>
+ * </p>
+ *
+ * @param nodePath the path to the node containing the property; may not be null
+ * @param property the name of the property to be set
+ * @param values the value(s) for the property; may be empty if any existing property is to be removed
+ */
+ void setProperty( String nodePath,
+ String property,
+ Object... values );
+
+ /**
+ * Set the supplied reference on the supplied node.
+ *
+ * @param nodePath the path to the node containing the property; may not be null
+ * @param property the name of the property to be set
+ * @param paths the paths to the referenced property, which may be absolute paths or relative to the sequencer output node;
+ * may be empty if any existing property is to be removed
+ */
+ void setReference( String nodePath,
+ String property,
+ String... paths );
+}
Added: trunk/dna-spi/src/main/java/org/jboss/dna/spi/sequencers/StreamSequencer.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/sequencers/StreamSequencer.java (rev 0)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/sequencers/StreamSequencer.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,68 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.spi.sequencers;
+
+import java.io.InputStream;
+import org.jboss.dna.common.monitor.ProgressMonitor;
+
+/**
+ * The interface for a DNA sequencer that processes a property as a stream to extract information from the content and store in
+ * the repository.
+ * <p>
+ * Implementations must provide a no-argument constructor.
+ * </p>
+ * @author Randall Hauch
+ */
+public interface StreamSequencer {
+
+ /**
+ * Sequence the data found in the supplied stream, placing the output information into the supplied map.
+ * <p>
+ * JBoss DNA's SequencingService determines the sequencers that should be executed by monitoring the changes to one or more
+ * workspaces that it is monitoring. Changes in those workspaces are aggregated and used to determine which sequencers should
+ * be called. If the sequencer implements this interface, then this method is called with the property that is to be sequenced
+ * along with the interface used to register the output. The framework takes care of all the rest.
+ * </p>
+ * <p>
+ * This operation should report progress to the supplied {@link ProgressMonitor}. At the beginning of the operation, call
+ * {@link ProgressMonitor#beginTask(double, org.jboss.dna.common.i18n.I18n, Object...)} with a meaningful message describing
+ * the operation and a total for the amount of work that will be done by this sequencer. Then perform the sequencing work,
+ * periodically reporting work by specifying the {@link ProgressMonitor#worked(double) amount of work} that has was just
+ * completed or by {@link ProgressMonitor#createSubtask(double) creating a subtask} and reporting work against that subtask
+ * monitor.
+ * </p>
+ * <p>
+ * The implementation should also periodically check whether the operation has been
+ * {@link ProgressMonitor#isCancelled() cancelled}. If this method returns true, the implementation should abort all work as
+ * soon as possible and close any resources that were acquired or opened.
+ * </p>
+ * <p>
+ * Finally, the implementation should call {@link ProgressMonitor#done()} when the operation has finished.
+ * </p>
+ * @param stream the stream with the data to be sequenced; never null
+ * @param output the output from the sequencing operation; never null
+ * @param progressMonitor the progress monitor that should be kept updated with the sequencer's progress and that should be
+ * frequently consulted as to whether this operation has been {@link ProgressMonitor#isCancelled() cancelled}.
+ */
+ void sequence( InputStream stream, SequencerOutput output, ProgressMonitor progressMonitor );
+
+}
Added: trunk/dna-spi/src/test/resources/log4j.properties
===================================================================
--- trunk/dna-spi/src/test/resources/log4j.properties (rev 0)
+++ trunk/dna-spi/src/test/resources/log4j.properties 2008-04-22 02:47:53 UTC (rev 96)
@@ -0,0 +1,16 @@
+# Direct log messages to stdout
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.Target=System.out
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %m%n
+
+# Root logger option
+log4j.rootLogger=INFO, stdout
+
+# Set up the default logging to be INFO level, then override specific units
+log4j.logger.org.jboss.dna=INFO
+
+# Jackrabbit logging
+log4j.logger.org.apache.jackrabbit=WARN, stdout
+log4j.logger.org.apache.derby=INFO, stdout
+
Modified: trunk/pom.xml
===================================================================
--- trunk/pom.xml 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/pom.xml 2008-04-22 02:47:53 UTC (rev 96)
@@ -11,7 +11,7 @@
<modules>
<module>dna-common</module>
<module>dna-maven-classloader</module>
- <module>dna-services</module>
+ <module>dna-repository</module>
<module>sequencers/dna-sequencer-images</module>
<module>dna-integration-tests</module>
</modules>
@@ -98,9 +98,14 @@
</dependency>
<dependency>
<groupId>org.jboss.dna</groupId>
- <artifactId>dna-services</artifactId>
+ <artifactId>dna-spi</artifactId>
<version>0.1-SNAPSHOT</version>
</dependency>
+ <dependency>
+ <groupId>org.jboss.dna</groupId>
+ <artifactId>dna-repository</artifactId>
+ <version>0.1-SNAPSHOT</version>
+ </dependency>
<!--
Rules
-->
Modified: trunk/sequencers/dna-sequencer-images/pom.xml
===================================================================
--- trunk/sequencers/dna-sequencer-images/pom.xml 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/sequencers/dna-sequencer-images/pom.xml 2008-04-22 02:47:53 UTC (rev 96)
@@ -33,7 +33,7 @@
</dependency>
<dependency>
<groupId>org.jboss.dna</groupId>
- <artifactId>dna-services</artifactId>
+ <artifactId>dna-spi</artifactId>
</dependency>
<!--
Testing (note the scope)
Modified: trunk/sequencers/dna-sequencer-images/src/main/java/org/jboss/dna/sequencer/images/ImageMetadataSequencer.java
===================================================================
--- trunk/sequencers/dna-sequencer-images/src/main/java/org/jboss/dna/sequencer/images/ImageMetadataSequencer.java 2008-04-22 01:42:33 UTC (rev 95)
+++ trunk/sequencers/dna-sequencer-images/src/main/java/org/jboss/dna/sequencer/images/ImageMetadataSequencer.java 2008-04-22 02:47:53 UTC (rev 96)
@@ -23,9 +23,8 @@
import java.io.InputStream;
import org.jboss.dna.common.monitor.ProgressMonitor;
-import org.jboss.dna.services.ExecutionContext;
-import org.jboss.dna.services.sequencers.SequencerOutput;
-import org.jboss.dna.services.sequencers.StreamSequencer;
+import org.jboss.dna.spi.sequencers.SequencerOutput;
+import org.jboss.dna.spi.sequencers.StreamSequencer;
/**
* A sequencer that processes the binary content of an image file, extracts the metadata for the image, and then writes that image
@@ -62,7 +61,7 @@
* </p>
* @author Randall Hauch
*/
-public class ImageMetadataSequencer extends StreamSequencer {
+public class ImageMetadataSequencer implements StreamSequencer {
public static final String METADATA_NODE = "image:metadata";
public static final String IMAGE_PRIMARY_TYPE = "jcr:primaryType";
@@ -83,8 +82,7 @@
/**
* {@inheritDoc}
*/
- @Override
- protected void sequence( InputStream stream, SequencerOutput output, ExecutionContext context, ProgressMonitor progressMonitor ) {
+ public void sequence( InputStream stream, SequencerOutput output, ProgressMonitor progressMonitor ) {
ImageMetadata metadata = new ImageMetadata();
metadata.setInput(stream);
metadata.setDetermineImageNumber(true);
More information about the dna-commits
mailing list